Privacy
Last updated 2026-11-19. Applies to the Keryn CLI (keryn, keryn-native), the VS Code, Chrome and Firefox extensions, the web
page, the JetBrains plugin and the desktop app (Free mode and Keryn Workbench).
In short
Section titled “In short”- Keryn scans on your machine (or your CI runner). Your code, findings and reports stay where Keryn runs.
- Keryn sends no analytics or crash reports.
- Enforced CLI builds require
keryn loginfor an online entitlement. These builds renew the entitlement and send the allow-listed usage counts described below. An offline licence sends nothing. - Keryn Cloud is a separate, opt-in service with its own sign-in.
- No cookies or browser storage are used to track you. The web page keeps a cache of scan and GitHub answers on your device and, only if you ask, your tokens for the tab, all listed under “What Keryn stores”.
- The table below lists the network calls for user-initiated actions and the enforced CLI entitlement and usage flow.
The network calls Keryn makes
Section titled “The network calls Keryn makes”This list is the complete set of places in the code that can open a network connection. A test (tests/privacy-doc.test.mjs) fails
if this table and the audited call sites in tests/security-config.test.mjs (KS-17) ever disagree.
| When | Where it connects | What is sent | Call site |
|---|---|---|---|
You type a public GitHub owner/repo and press scan (Chrome/Firefox extension, web page) |
codeload.github.com |
A request for that repository’s zip. No cookies, no credentials, no referrer. | src/host/fetch.ts |
You type a public GitHub owner/repo (or a repository link) and press scan on the web page (keryn.app) |
api.github.com, raw.githubusercontent.com, and (with archive consent) api.keryn.app |
The repository’s latest commit and file list, then an immutable public archive through Keryn without storage, or direct source files when the person chooses direct mode. Token archives require a public-repository check; private repositories stay direct. Archive failure never silently changes modes; then, automatically after every scan, the repository facts and assessment: up to four facts requests (repository details, latest releases, community profile, a one-entry contributor page for the count) and up to seven assessment requests (the top ten contributors’ public logins and commit counts, languages, the owner’s public profile, the file list, the last 50 closed pull requests and issues, and an organisation’s public members), plus the manifests and workflow files the technology detection reads from raw.githubusercontent.com. They stay within the hour’s remaining requests (read from /rate_limit, which GitHub does not count), keep a few back for the next scan (three anonymous, fifty with a token), and name what they left out. Contributor logins are shown in the result and kept with the saved report in this browser; the CycloneDX export carries only aggregates. No email address is read. raw.githubusercontent.com stays anonymous. No cookies, no credentials, no referrer. An Accept header, an If-None-Match header carrying the ETag of an answer cached on your device (GitHub does not count a 304 against the limit), and, only if you pasted a GitHub token, an Authorization: Bearer header to api.github.com and nowhere else. Counts against GitHub’s 60 requests per hour per address (5,000 with a token). |
src/host/fetch.ts |
| A page lists the repositories of a GitHub organisation or user you named | api.github.com |
GET /orgs/{name}/repos, then GET /users/{name}/repos if that is not an organisation, page by page (public repositories only). The same headers as above, and the optional token only as Authorization: Bearer. |
src/host/fetch.ts |
You enter a public Bitbucket Cloud workspace/repo on the web page |
api.bitbucket.org |
The repository’s main branch, the commit and file list, then each file’s bytes. No cookies, no credentials, no referrer, no token. Bitbucket allows about 60 anonymous requests an hour, so a repository of up to 40 files downloads. | src/host/fetch.ts |
| You open the extension popup on a site and run the trust scan or the AI stack scan | That site only (the current tab’s origin) | Requests for that site’s own pages, as a visitor without cookies or credentials would make them. Nothing about you or your code. | src/host/fetch.ts |
| You enter a GitHub, GitLab or Bitbucket repository on the point-and-shoot web page | api.github.com, raw.githubusercontent.com, gitlab.com, api.bitbucket.org (the host you chose) |
Read requests for that repository’s file list and files. No cookies. A token, only if you type one, goes to that host’s API only (the point-and-shoot page). | src/sources/remote.ts |
| The web page or an extension loads its own engine files | The page’s or extension’s own origin (inside the extension: no network at all) | Requests for Keryn’s bundled WebAssembly, rules and data. | src/host/assets-url.ts |
| Deep scan in the browser loads its engine | The page’s or extension’s own origin | A request for Keryn’s bundled Deep WebAssembly (its content pack is read from the rule vault, not fetched file by file). | src/browser/wasi-scan-worker.ts, src/browser/deep-module-cache.ts |
| The rule vault is loaded | The page’s or extension’s own origin | One request for Keryn’s bundled rule vault module. | src/host/vault.ts |
| You set up a connector (Settings → Connectors) and press Test, Triage or Send on the web page | The one address you configured for that connector (an AI provider, an AI gateway, a model server, your Supabase project, or your own Keryn relay); http only for localhost |
Test: a model listing, a one-row read or the relay’s health. Triage, after you confirm: up to 60 findings (rule, message, file, line, proof, taxonomy and, if you leave it ticked, a few lines of code around each with credential-like text masked) and the key you entered. Send: the findings and verdicts as rows, or the evidence graph as Cypher statements. No cookies, no referrer, no redirect to another host. Keys stay in the tab’s memory unless you choose to remember them for the tab. Nothing is sent on its own. | src/host/connector-fetch.ts |
You press Create issues in the Decision Desk (web page, after a preview of every payload), or run keryn decide export --github owner/repo or --gitlab project (not under --dry-run) |
The one tracker you named: api.github.com or gitlab.com on the web page; from the CLI also a GitHub Enterprise or self-managed GitLab address you gave with --github-url / --gitlab-url (https; http only for localhost) |
First a search of that repository or project for each issue’s keryn:issue marker, then one create-issue request per chain or chokepoint: a title and a body with the rule ids, file paths and line numbers, severities, proof levels, the scan’s coverage statement and the finding fingerprints’ first characters. No code snippets. Your token goes in the Authorization header to that one host only: on the web page from the connector store (tab memory unless you remembered it), in the CLI from GITHUB_TOKEN / GITLAB_TOKEN (never a flag, never printed). No cookies, no referrer, no redirect to another host. Nothing is sent on its own. |
src/host/connector-fetch.ts |
| You sign in to Keryn Cloud and run a cloud scan (web page, Cloud) | api.keryn.app (sign-in and scans); with the older sign-in link, Keryn’s Supabase project |
Sign-in: the email address you type, then a session token. A scan: the address you typed (a website, a host name or an MCP server URL) and your session token; adding a domain: the domain name. Never any code, file or local result. No cookies, no referrer. | src/host/cloud.ts |
You run keryn login, keryn whoami, or a release build of the CLI after signing in |
The Keryn service you signed in to (KERYN_SERVER, default api.keryn.app) |
Sign-in: a device name (your host name unless --name) and the pairing code. Then, with the device token: this device’s public key and the ids of the rule vaults the build ships, to receive an entitlement. Usage after a command: the command name, a size class, the outcome, the duration, whether Deep ran and the minute, nothing else (no path, repository, code, file or finding). An offline licence sends nothing. |
src/host/account-fetch.ts |
| You check a locally minted ownership challenge, or run verified active ZAP/Nuclei | The challenged domain’s TXT records and HTTPS well-known file; exact explicit loopback origin for a local preview | Fresh proof before a scan. Same DNS TXT/file token protocol as Cloud. No cookies, credentials or scanner probes. Receipt stores token/challenge hashes, never the local issuer key. | src/host/ownership-node.ts |
You run keryn dast scan <url> --active (CLI only) |
The target you named, and only paths inside its subtree | After ZAP’s scan: up to nine POST requests, each an MCP initialize (the body ZAP’s Open MCP Server Detection script sends), to the script’s probe paths that lie inside the target subtree, stopping at the first MCP server that answers. No cookies, no credentials, no referrer, redirects not followed; at most 1 MiB of each answer is read (an event stream for two seconds). |
src/host/fetch.ts |
You run keryn ai with your own model key on a device paired to your Keryn account |
The Keryn service the device is paired to | A random run ID and input and output token totals, authenticated with the device token. The account records zero credits and Keryn keeps these receipts out of Metronome. Signed-out devices and offline licences keep usage local. | src/host/account-fetch.ts |
You run keryn scan --online, or click “Check dependencies” on a web report that says its lockfiles were not checked (later scans keep checking until you click “Stay offline”), and the scanned tree has lockfiles |
api.osv.dev |
The ecosystem, name and version of each locked dependency (POST /v1/querybatch), then the ids of the advisories it lists (GET /v1/vulns/{id}). Never code, file names or paths. No cookies, no credentials, no referrer, no redirect. Off by default; the desktop app never makes it. |
src/host/fetch.ts |
You run keryn scan --online and the scanned tree has locked packages whose lockfile and vendored metadata record no licence (npm via pnpm/Yarn/Bun, PyPI, Go, crates.io, Maven, NuGet, RubyGems) |
api.deps.dev |
The ecosystem, name and version of each such package, in the path of GET /v3/systems/{system}/packages/{name}/versions/{version}, to read the licence the registry declares. Never code, file names or paths. No cookies, no credentials, no referrer, no redirect. Answers are cached on disk beside the advisory cache. Off by default; Keryn Web and the desktop app do not make it. |
src/host/fetch.ts |
You run keryn sca db update --from https://... (CLI only) |
The HTTPS address you typed, and only paths under it | GET requests for the advisory export files (<ecosystem>/all.zip) of the ecosystems you chose. Nothing about your code or dependencies is sent: the whole export is downloaded and the lookup happens on your machine. No cookies, no credentials, no referrer, redirects not followed. keryn scan and keryn sca image then read the installed snapshot with no network. |
src/host/fetch.ts |
You run keryn sca image <reference> --pull (CLI only; also keryn ci --sca-image <reference> --sca-image-pull) |
The registry in the reference you typed, and the token endpoint that registry’s own 401 answer advertises. With --pull-redirects, also the storage host the registry redirects a layer download to |
GET requests of the OCI distribution API: the image manifest, then its config and layers by digest. The repository name and tag or digest are in the path. KERYN_REGISTRY_USERNAME and KERYN_REGISTRY_PASSWORD go to the token endpoint (or to the registry on a Basic challenge), KERYN_REGISTRY_TOKEN to the registry; a storage host gets neither. HTTPS only (plain HTTP for a registry on 127.0.0.1). No cookies, no referrer; redirects are not followed without --pull-redirects. Nothing is requested without --pull. |
src/host/registry-net.ts |
| ZAP reserves its per-invocation proxy port | An ephemeral listener on 127.0.0.1, immediately closed before ZAP starts | No outbound connection or request. Port selection does not grant target ownership. | src/host/loopback-port-node.ts |
You run keryn sca scan or keryn dast scan (also through keryn ci) |
Whatever the scanner you installed contacts: OSV-Scanner stays offline unless you pass --online (then its advisory queries and database downloads); ZAP sends HTTP requests to the target you named, and attack requests only with --active |
Keryn starts the locally installed binary (shell: false, the runner’s environment) and reads its report from disk. Keryn itself sends nothing. |
src/services/scanner-adapters/sca.ts, src/services/scanner-adapters/zap-process.ts |
A pull-request gate in CI runs with release.require_signature on (the trusted job of a GitHub pull_request event) |
api.github.com |
GET /repos/{owner}/{repo}/pulls/{number}/reviews, at most three pages, to find an approving review of the head commit by someone other than the author (#116). The repository, PR number and head commit come from the trusted event. The job’s KERYN_REVIEW_TOKEN or GITHUB_TOKEN goes as Authorization: Bearer to api.github.com only. Reviewer logins are used for the decision and named on it; nothing else is read or kept. Without a token nothing is sent and the signature requirement stays unmet. The request is built in src/host/github-review.ts. |
src/host/fetch.ts |
| You host the GitHub App and a pull request changes (next release, not registered) | GitHub to your app server (signed pull_request webhooks, up to 1 MiB); your app server to api.github.com; your Actions runner to your app server and to the HTTPS address of the pinned CLI tarball |
The server receives webhooks and the runner’s signed result bundles (up to 12 MiB) and calls the GitHub API for an installation token, the pull request, a workflow dispatch and the Check. The runner downloads the CLI tarball whose sha256 is pinned (no redirect, 2-minute timeout) and runs it with shell: false. Nothing is sent to Keryn. |
clients/github-app/app.mjs, clients/github-app/runner.mjs |
| You host the Slack review adapter (next release, pilot) | Slack to your adapter (signed slash commands and button presses, up to 128 KiB); your worker to your adapter (a signed completion receipt); the offline demo only to its own server on 127.0.0.1 |
The adapter answers commands from recorded evidence and posts a review card to a channel only when writes are enabled for it and a person presses Share. Slack cannot supply a URL, path, command or secret name. Nothing is sent to Keryn. | clients/slack-app/app.mjs, clients/slack-app/demo.mjs |
You run keryn nday-db update --from https://... |
The https address you gave | A request for the signed known-fix database files at that address. No credentials. Never runs on its own. | ../apps/keryn-cli/src/commands/seceng_nday_db.rs |
| Keryn Workbench (desktop, Workbench mode) talks to its own local server | 127.0.0.1:8778 (this computer only) |
The app’s requests to the keryn-server it started (graph, evidence export, correlations). Nothing leaves the computer. | ../apps/keryn-desktop/src/workbench/commands.rs, ../apps/keryn-desktop/src/workbench/sidecar.rs |
The CLI, the language server (VS Code, JetBrains, other editors) and the desktop app in Free mode make no network connection at all,
except explicit keryn nday-db update --from https://..., keryn decide export (without --dry-run), keryn scan --online (dependency advisories, above), keryn sca scan --online, keryn dast scan, and keryn ai-test run operations (also available through keryn ci). OSV-Scanner runs offline by default using its pre-provisioned advisory database; online mode permits advisory queries and database downloads. ZAP sends HTTP requests to the specified target even in passive mode; --active additionally enables active attack checks and Keryn’s own MCP probe (the table above). The OSV/ZAP commands execute locally installed scanner binaries with the runner’s environment; AI regression tests use the built-in bounded HTTP runner. They do not install scanners or create services. Imported reports are read locally. Reading a git history (--base <ref>) runs your local git against your local
clone; nothing is fetched.
Keryn Cloud
Section titled “Keryn Cloud”Keryn Cloud is optional and separate from everything above: you use it only by opening Cloud (keryn.app, or the account pages at
api.keryn.app) and signing in. Nothing from your machine (code, local scans, posture answers) is sent to it.
Your account. You sign in with an email address and password (with a verification email), a passkey and an authenticator app, or GitHub, Google or Microsoft if you choose one of them. An organization can require single sign-on through its own identity provider (OpenID Connect or SAML) and can provision its members from a directory (SCIM); when it does, your identity provider tells Keryn your email address, name and group membership, and is your own service, not a Keryn sub-processor. The browser extension, the desktop app and the CLI sign in by pairing a device with your account; the device holds a token and a public key, and Keryn records the device’s name and when it was last used.
What Keryn Cloud keeps, per organization. Your email address and name; the organization’s members, roles, teams and security policy; the domains you add, with their verification token and when they were verified; the cloud scans you run (what you asked to scan, when, a summary and the report); results you choose to upload, with triage decisions and share links; usage receipts and the credit ledger; and an audit trail of who did what (sign-ins, membership and policy changes, exports, deletions), which organization owners and admins can read and export. Billing uses Stripe test mode and Metronome sandbox with a shadow meter. The service stores the organization’s Stripe customer reference and payment events. Card details are entered at Stripe and never reach Keryn.
How scans run. Scans are run from Keryn’s servers against the address you typed: a website’s public pages (as an anonymous visitor would read them), a host’s public AI services (active port checks only on domains you have verified), or a remote MCP server’s handshake and lists (Keryn never calls one of its tools). An agentic task you start (triage, summary, remediation) sends that task’s content, capped per task, to the model provider; local scans and ordinary hosted scans do not.
Who processes it. Hosting (Vercel), the Postgres database (Supabase), payments (Stripe), usage and credit records (Metronome),
transactional email (Resend), the model provider for tasks you start, and GitHub when you sign in with it or connect a repository.
The list, what each handles and where, with 30 days’ notice of changes, is at https://keryn.dev/subprocessors/. Data is held in
the US (Vercel iad1, Supabase AWS us-east-1).
How long it is kept. Uploaded results, cloud scans and their bodies: the organization’s retention setting, 365 days by default (1 to 730). Audit history: 395 days. Revoked or expired share links: 30 days. Usage receipts, the credit ledger and payments are kept for accounting and cannot be deleted by a customer. Backups: nightly for 30 days, pre-migration for 90 days; a restore replays every deletion made since, so deleted data does not come back. Details: https://keryn.dev/docs/ (Keryn Cloud, data lifecycle).
Hosted AI attribution. If you submit commit and pull request metadata for attribution, Keryn uses it to count signals of AI assistance. Keryn does not retain the submitted metadata or the resulting report. Reports default to aggregate totals and breakdowns. Organization administrators who request developer rows receive pseudonyms unless they explicitly request names and email addresses. The service records the administrator and time of any identity reveal in the organization audit trail. This record does not contain the revealed identities.
Organizations with the attribution policy controls can set a commit lookback from 1 to 730 days (default 365) and enable aggregate-only mode. That mode blocks developer rows, suppresses groups smaller than three contributors, and omits individual evidence and time series. The lookback governs hosted analysis. Customers control retention of any reports they save.
Self-serve. An organization admin can export the organization’s data (one JSON object per line), export the audit trail, change retention, delete any single result or cloud scan, and delete all hosted evidence in one step, from the account’s Data page or the API. Closing an account or an organization (members and billing records) is done by request, below.
Your requests
Section titled “Your requests”To see, correct, export or delete what Keryn holds about you, or to close an account or organization, write to
security@keryn.dev from the email address on the account. Replying from that address is how we check it is you; for an
organization, the request must come from an owner or admin. We answer within 30 days, and say what we did and what we kept and why
(for example billing records that accounting rules require us to keep). Export and deletion of hosted evidence do not need a
request: use the Data page. Security reports go to the same address (see SECURITY.md); put “privacy request” in the subject.
The keryn-server binary that Workbench starts also contains integration endpoints (an LLM chat passthrough, an evidence push and a local HTTPS inspection proxy) that connect to addresses you configure. The Workbench app does not call them; they act only if you run and call keryn-server yourself.
What Keryn stores
Section titled “What Keryn stores”On the web page, in your browser only and never sent anywhere by Keryn:
- GitHub response cache. The text of GitHub’s answers to the requests above (repository lists, commit and file lists, release lists and community profiles of public repositories, or of any repository your token can read if you used one) is kept in IndexedDB (database
keryn-gh-cache; if the browser blocks IndexedDB there is simply no cache) with its ETag, so a repeat request can be answered without using your quota. Entries older than 7 days are dropped. The cache key holds a short fingerprint of your token (a truncated SHA-256), never the token, and a response fetched with one token is never used for another or for anonymous requests. Contributor lists carry people’s names, so/contributorsanswers are never cached and Keryn reads only how many contributors there are. (A release list does name the person who published each release, as GitHub shows publicly; it stays in this cache on your device and no name or email is written to a report or an AI-BOM.) - Scan cache. So that scanning something that has not changed costs almost nothing, the web page keeps the finished report of each scan, and the pattern-rule matches of each file, in IndexedDB (database
keryn-rescan; at most 256 MB, the least recently used entries go first; if the browser blocks IndexedDB there is no cache). A report includes the findings with the few lines of code each quotes, so it holds snippets of the code you scanned. Entries are keyed by digests of the file contents, the rules and the settings, or by the commit of a public GitHub repository; they never contain a token. Settings → Clear cache (and Clear saved data) deletes them. - Your GitHub token, if you paste one: held in the tab’s memory, and in
sessionStorageonly if you tick “remember for this tab” (cleared when the tab closes). It is sent as a Bearer header toapi.github.comonly. Clearing it stops any queued repository downloads that would use it. - Connector keys (AI model, Supabase, FalkorDB, Neo4j, issue trackers): in the tab’s memory, and in
sessionStorageonly if you tick “remember for this tab”. Their non-secret settings (address, model, table) are inlocalStorage. Each key is sent only to the address you configured for it. Forget removes it and stops a triage run that is using it. - Your Keryn Cloud sign-in (a device token): in
sessionStorage, for this tab only, unless you tick “Stay signed in on this device”, which keeps it inlocalStorage. Sign out removes it from both. - Repository connection tokens (Azure DevOps, Bitbucket, GitLab): in memory only. Removing a connection stops queued work that would use it.
Before anything is sent to a data connector (Supabase, FalkorDB, Neo4j), the page shows the destination and exactly what is sent and what is not, and sends only when you press Send. AI triage does the same before its first request. Tokens never appear in a URL, an exported file, the console or a diagnostic bundle (e2e/local-first.spec.ts).
Elsewhere:
Under an offline licence (contract customers) the CLI sends nothing and keeps one file in its private configuration directory, licence-usage.json: counts per month of each run’s command, size class, outcome and whether Deep ran. It holds no path, repository name, code or finding. keryn licence usage reads it and, with --out, writes a report with a digest for a contract that prices by usage; Keryn receives that report only if you send it. A machine without a licence has no such file.
Reports, SARIF files, AI-BOMs and evidence bundles are written where you tell Keryn to write them. Deep scans stage their
engine files in a fresh private temporary directory per run. The known-fix database lives in the package or in your
user data directory after nday-db update. The CLI, the language server and the editor extensions that use them keep the same scan cache as files in your user cache directory (macOS ~/Library/Caches/keryn/rescan, Linux $XDG_CACHE_HOME/keryn/rescan or ~/.cache/keryn/rescan, Windows %LOCALAPPDATA%\keryn\Cache\rescan; KERYN_CACHE_DIR moves it): one file per scan with the same content as above, readable only by you, at most 512 MB. keryn scan --no-cache (or KERYN_NO_CACHE=1) neither reads nor writes it, and keryn cache clear deletes it. Nothing in the cache is ever sent anywhere. External scanner runs also write raw reports, execution metadata and normalized findings under the explicit --out directory. Those files may contain request/response evidence from the scanner and should be handled like source-code artifacts. Keryn keeps no other history of your scans and sends none.
Third parties
Section titled “Third parties”When you use one of the calls above, the host you connect to (GitHub, GitLab, Bitbucket, the site in your tab, or the address you gave for a database update) sees an ordinary request from your network address under its own privacy policy. The browser stores and editor marketplaces you install Keryn from have their own policies.
Contact
Section titled “Contact”Questions about this page and privacy requests: security@keryn.dev (see “Your requests”). Security vulnerabilities: SECURITY.md.
AI security regression workflows
Section titled “AI security regression workflows”keryn ai-test run sends the reviewed suite’s requests to its declared HTTP(S) origin. Actor credentials are resolved from named environment variables and used only in memory. Redirects are refused; actors are verified before and after trials. The runner writes request-declaration and response digests and check outcomes, omitting resolved credentials, headers and raw response bodies. Suite identifiers and optional model/configuration metadata are caller-supplied and appear in receipts; do not put secrets in those fields. The reviewed suite remains your local source of routes, synthetic inputs and assertions.
ai-test validate sends no requests. ai-test capture reads a local HAR file and emits a non-runnable draft with captured path/query/header/body literals redacted; original capture bytes are not copied to its output. Explicit target origin, application and revision remain visible. The Burp extension’s export action saves similarly redacted local input and has no network transport.
sca inventory runs locally and retains original report, binding, snapshot and baseline bytes alongside normalized package/provenance data. Those artifacts may contain sensitive producer metadata. The output directory must be new or empty; generated files use private permissions. CI creates digest-bound artifact references and explicit associations; it does not upload them.
Public GitHub archive mode is explicit opt-in on the Scan card: the repository slug, immutable SHA and public source bytes stream through api.keryn.app without source storage; no cookie/token is forwarded. A signed-in scan first asks GitHub whether the repository is public. Private files and direct mode use GitHub API file reads. Call site: src/host/github-archive.ts. See ../docs/keryn/github-acquisition.md.
GitHub App sign-in is an explicit device-code exchange through the build’s Keryn Cloud origin (src/host/cloud.ts). Device codes and the resulting user access token pass through that service without logging or persistence; refresh tokens are discarded. The token stays in tab memory and subsequent repository requests send it only to api.github.com. The owner configures the App permissions and installed repositories. Public archive consent is separate from sign-in.