Keyorix
Lightweight secrets management for teams that can't use SaaS.
On-premise. Air-gapped ready. Single binary. No Vault admin required.
Power your agent
पब्लिशर का इंस्टॉल। PlugMCP एंडपॉइंट नहीं।
Host a copy with our keys and logs.
रजिस्ट्री में अभी कोई पैकेज्ड रिलीज़ नहीं है। रिपॉज़िटरी का README देखें.
रिमोट URL या आपकी मशीन पर कमांड? दोनों इंस्टॉल में क्या अंतर है
PlugMCP पर चलाएँ
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
लॉन्चपब्लिशर से
Lightweight secrets management for teams that can't use SaaS.
On-premise. Air-gapped ready. Single binary. No Vault admin required.
Lightweight on-premise secrets management for European enterprises. AGPL. No SaaS dependency. Air-gap compatible. NIS2/DORA aligned. AI-native via MCP server — roadmap
| Vault | Doppler | Keyorix | |
|---|---|---|---|
| On-premise | Yes | No | Yes |
| Air-gapped¹ | Yes | No | Yes |
| Simple ops | No | Yes | Yes |
| EU company | No | No | Yes |
| Open source | BSL | No | AGPL |
| Single binary | Yes | N/A | Yes |
¹ The core product needs no internet access. Optional integrations that delegate to an external identity provider — OIDC machine-identity federation, SSO login — need network reachability to that provider (which can itself live entirely inside a private network with no internet egress). See Configuration for what's required.
Vault is powerful but requires a dedicated admin. Doppler is simple but SaaS-only. Keyorix is both simple and runs entirely in your infrastructure.
curl -L https://raw.githubusercontent.com/keyorixhq/keyorix/main/install.sh | sh
That installs the keyorix CLI only (Linux and macOS, amd64 and arm64). The server
(keyorix-server) is a separate release asset (keyorix-server_<os>_<arch> for
linux/darwin on amd64/arm64, plus a Linux-only -airgap variant, with
checksums.txt) — see QUICK_START.md — or a
container image (ghcr.io/keyorixhq/keyorix-server).
Or build from source (Go only; no C toolchain, the SQLite driver is pure Go):
git clone https://github.com/keyorixhq/keyorix
cd keyorix && make install
Self-host the full stack (web UI + API + PostgreSQL) with Docker Compose:
git clone --branch v0.96.3 https://github.com/keyorixhq/keyorix.git && cd keyorix # the compose file, .env.example and scripts/selfhost/ live in the repo; use a release tag, main can be ahead of the published images
cp .env.example .env
./scripts/selfhost/init-secrets.sh # generates ./secrets/* (Docker secrets files); admin password is in ./secrets/admin_password
docker compose up -d # open http://localhost:8088
See docs/SELF_HOSTING.md for production setup (TLS,
backups, upgrades, and the all-important encryption-key handling), and
docs/CONFIGURATION.md for the full keyorix.yaml
reference (encryption/KEK providers, MFA, WebAuthn, dynamic secrets, OIDC, …).
Running on edge or industrial devices, unattended or air-gapped sites:
docs/edge-deployment.md.
Or run just the server binary (the server needs a config, encryption keys and a
migrated database first, written by admin init; the passphrase comes from a file
or a prompt, not a command line):
keyorix-server admin generate-secrets # master passphrase, bootstrap token, admin password: 0600 files in ./secrets
export KEYORIX_MASTER_PASSWORD_FILE=secrets/master_password KEYORIX_BOOTSTRAP_TOKEN_FILE=secrets/bootstrap_token
keyorix-server admin init
keyorix-server admin encryption init
keyorix-server admin migrate
keyorix-server
QUICK_START.md has the full sequence, including creating the first admin.
Log in with the CLI:
keyorix login --server https://localhost:8080 --ca-file certs/server.crt --username admin
# Password: (typed at the no-echo prompt)
(certs/server.crt is the self-signed certificate keyorix-server admin init
generated; login remembers the CA file for later commands.)
With an authenticator app enrolled, login prompts for a code after the
password (an unused recovery code works too).
Create and use secrets (passwords and values are prompted or read from a file, not passed as flags, because command-line arguments are visible via ps and saved in shell history):
keyorix secret create --name db-password --interactive # value typed at a hidden prompt
keyorix run --env production --var DATABASE_URL=db-password -- node app.js
keyorix run --env production --var DATABASE_URL=db-password -- flask run
keyorix run --env production --var DATABASE_URL=db-password -- ./myapp
Secrets are injected as environment variables under the name YOU choose with
--var NAME=secret-ref (repeatable). The old behavior — auto-deriving the env
var name from the secret's own name (db-password becoming DB_PASSWORD) — is
still available via the deprecated --derive-names flag, but is no longer the
default: it let whoever names a secret also choose the env var it becomes.
# From Vault (Medusa YAML export)
keyorix secret import --file vault-export.yaml --format vault --project 1 --env 1
# From .env files
keyorix secret import --file .env --format dotenv --project 1 --env 1
# Preview before importing
keyorix secret import --file vault-export.yaml --format vault --project 1 --env 1 --dry-run
For a live Vault/OpenBao instance (rather than a static export file) —
including AWS/Azure/GCP secret managers — use keyorix-migrate, a separate
release binary (keyorix-migrate_<os>_<arch>) that connects directly and
imports over the Keyorix REST API. See
docs/migrate-from-vault.md and
docs/migrate-from-cloud.md.
Fetch secrets directly from your application at startup. Zero hardcoded credentials.
Go, Python, Node.js, and Java SDKs live together in
keyorixhq/keyorix-sdks
(github.com/keyorixhq/keyorix-go is archived — superseded by the go/
directory there). Recommended for an app running unattended: authenticate
with a machine identity token (keyorix machine token issue <name|id>),
not a user's password — see docs/sdks.md for the full
picture, including PATs, error handling, and TLS with a private CA.
Go
go get github.com/keyorixhq/keyorix-sdks/go
client, _ := keyorix.New("https://your-server:8443", os.Getenv("KEYORIX_TOKEN"))
dbPassword, _ := client.GetSecretScoped(ctx, "db-password",
keyorix.ProjectByName("my-project"), keyorix.EnvironmentByName("production"))
Python (from source: not verified yet, see the note below)
client = keyorix.Client("https://your-server:8443", os.environ["KEYORIX_TOKEN"])
db_password = client.get_secret_scoped("db-password", "my-project", "production")
Node.js (from source)
git clone https://github.com/keyorixhq/keyorix-sdks.git
npm pack ./keyorix-sdks/node
npm install ./keyorixhq-sdk-0.3.0.tgz
const client = new keyorix.Client("https://your-server:8443", process.env.KEYORIX_TOKEN);
const dbPassword = await client.getSecretScoped("db-password", "my-project", "production");
Java (from source: not verified yet, see the note below)
KeyorixClient client = Keyorix.newClient("https://your-server:8443", System.getenv("KEYORIX_TOKEN"));
String dbPassword = client.getSecretScoped("db-password", "my-project", "production");
Packages are not published yet. pip install keyorix,
npm install @keyorixhq/sdk and the com.keyorix:keyorix-sdk Maven
dependency do not work today: nothing is on PyPI, npm or Maven Central. Only
the Go module resolves from a registry. The Node.js steps above (clone, pack,
install the tarball) were run and the package loads. A from-source install of
the Python and Java SDKs has not been verified yet; use the python/ and
java/ directories of the keyorix-sdks clone and their READMEs.
Each language's examples/petstore/ directory in
keyorix-sdks has a full
working demo with Docker Compose. No release has been tagged for
keyorix-sdks yet — see that repo's own COMPATIBILITY.md for the
current verified-compatible state.
Secrets management
Access control
Audit and compliance
audit_events and secret_access_logsDeveloper experience
keyorix run — inject secrets into any processkeyorix secret import — migrate from Vault, .env files, JSONkeyorix login — single command server authenticationkeyorix_get_secret,
keyorix_list_secrets), no write/rotate/delete tools (ADR-061)Two binaries: a thin keyorix CLI that only ever talks REST to a server, and the
keyorix-server binary itself (HTTP REST on port 8080 by default; a partial gRPC
surface on port 9090, off unless server.grpc.enabled). A server built with make build-ui serves the web UI on the HTTP port;
the Docker Compose stack publishes it on 8088. The CLI has no local database mode and cannot bypass the server's own
authorization/audit — see docs/ARCHITECTURE.md for the full
picture, including keyorix-server admin's offline, host-side operations (recover a
locked-out admin, offline backup/restore, independent audit-chain verification).
SQLite for development and small teams. PostgreSQL for production.
Air-gapped deployment: copy the keyorix-server binary and run — no internet required,
and an air-gapped build profile excludes every cloud-SDK dependency entirely (see
docs/ARCHITECTURE.md).
(Optional features that delegate to an external identity provider — OIDC federation, SSO
login — need network reachability to that provider; see
Configuration.)
Security issues: [email protected]
AGPL-3.0. Commercial licensing available for enterprise deployments.
Contact: [email protected]
Built by Andrei Beshkov, ex-Microsoft Security PM, Valencia, Spain.
Keyorix SL — your data stays in your infrastructure.
Lightweight on-premise secrets management for European enterprises. AGPL. No SaaS dependency. Air-gap compatible. NIS2/DORA aligned. AI-native via MCP server — roadmap
टूल
अभी टूल सूची नहीं है। रिमोट सर्वर को पहले हेल्थ चेक के बाद सूची मिलती है।
FAQ
इस पेज पर Cursor, Claude Desktop, Claude Code या VS Code के लिए stdio कॉन्फ़िग कॉपी करें। यह पब्लिशर का इंस्टॉल इस्तेमाल करता है, PlugMCP प्रॉक्सी नहीं।
इस रिकॉर्ड में कोई ज़रूरी एनवायरनमेंट वेरिएबल दर्ज नहीं है।
Keyorix stdio पर लोकल चलता है।
पिछली जाँच 2026-10-27 को हुई। Lightweight on-premise secrets management for European enterprises. AGPL. No SaaS dependency. Air-gap compatible. NIS2/DORA aligned. AI-native via MCP server — roadmap