Développeurs

Un appel CLI. Tous les secrets.

Pas de variables d'environnement. Pas de fichiers de configuration. Pas de secrets dans les logs. Tous les secrets dont votre code a besoin, résolus à l'exécution à partir d'un coffre-fort que votre agent ne peut pas contourner.

Le modèle

Stockez-le une fois. Récupérez-le n'importe où.

Chaque agent est initialisé une fois avec son propre jeton, ses portées et ses limites de débit. Après cela, l'agent peut récupérer les secrets à l'exécution. La clé est stockée chiffrée dans le coffre-fort, jamais dans les variables d'environnement ou le code source. Si la clé tourne, mettez-la à jour dans l'interface utilisateur du coffre-fort — chaque agent la récupère automatiquement.

# One-time setup — paste the token at the prompt, or pipe it in
$ echo "$CLAVITOR_TOKEN" | clavitor-cli init

# Single value — piped, never stored
$ clavitor-cli get "Deploy Key" --field private_key | ssh-add -

# Whole config — secrets resolved, template safe to store anywhere
$ clavitor-cli render app.config.json | myapp --config -

# Proxy — credentials injected at the network layer
$ export HTTPS_PROXY=http://localhost:1983
$ curl -H "Authorization: Bearer clavitor://OpenRouter/key" https://openrouter.ai/api/v1/models

Trois façons de l'utiliser

Champ, Rendu ou Proxy.

Champ

Une valeur. Envoyez-la dans n'importe quelle commande ou script. Le secret n'existe que dans le pipe — jamais dans une variable, jamais sur disque.

Rendu

Fichier de configuration entier. Résolvez toutes les références clavitor:// au démarrage. Le modèle est sûr à commiter. La configuration résolue vit dans un pipe.

Proxy

Proxy HTTPS. Identifiants résolus à partir des en-têtes de manière transparente. L'agent écrit clavitor:// là où le secret doit aller — le proxy injecte la vraie valeur. Rien dans les logs, rien dans la mémoire de l'agent.

Lequel devrais-je utiliser ?

Fonctionnalité	Field	Render	Proxy
Secrets hors des logs
Fonctionne avec n'importe quel langage
Fonctionne avec n'importe quel outil (curl, SDK, navigateur)
Portée et audit par agent
Plusieurs secrets à la fois
Aucune modification de code nécessaire
Fichiers de configuration sûrs à commiter
Cas d'utilisation SSH / non-HTTP

Choix rapide : Vous créez un script ou un outil CLI ? Utilisez Champ. Vous déployez un service avec un fichier de configuration ? Utilisez Rendu. Vous exécutez des agents IA qui effectuent des appels API ? Utilisez Proxy.

Pourquoi cela surpasse tous les autres proxys d'identifiants.

Rien à voler. Les proxys hébergés dans le cloud sont des cibles de grande valeur — compromettez-en un et vous obtenez les identifiants de tous les clients. Les proxys locaux stockent les identifiants dans leur propre configuration, lisible par n'importe quel agent sur la machine. Le proxy Clavitor ne contient qu'un fichier de configuration chiffré. Pas de secrets en clair sur disque, pas de magasin d'identifiants à piller.

Les agents ne peuvent pas l'ouvrir. Un agent compromis ne peut pas extraire les identifiants du proxy — le proxy n'expose pas d'API, ne sert pas de tableau de bord, et n'accepte pas de commandes. Il lit un en-tête, résout une référence, et injecte le résultat dans la requête sortante. Aucune surface d'attaque.

Rien dans les logs. L'agent écrit clavitor://Entry/field. C'est ce qui apparaît dans stdout, dans les logs, dans l'historique des conversations. L'identifiant réel n'existe qu'à l'intérieur du processus proxy pendant la durée d'un appel HTTP. Agrégateurs de logs, dumps de crash, artefacts CI — tout est propre.

Configuration zéro. Pas de tables de routage, pas de mappages d'API, pas de fichiers d'identifiants à gérer. La référence clavitor:// dans l'en-tête est la seule instruction. Une init, une variable d'environnement, c'est fait.

Langages

Fonctionne dans tous les langages. Aucun SDK requis.

Bash

# The proxy handles credential injection — no secrets in the command
$ export HTTPS_PROXY=http://localhost:1983
$ curl -H "Authorization: Bearer clavitor://OpenRouter API/key" \
  https://openrouter.ai/api/v1/models

Go

key, _ := exec.Command("clavitor-cli", "get", "OpenRouter API", "--field", "key").Output()
client := openai.NewClient(option.WithAPIKey(strings.TrimSpace(string(key))))

Python

import subprocess
# Pass directly — or use the HTTPS proxy to avoid holding the key entirely
stripe.api_key = subprocess.check_output(
    ["clavitor-cli", "get", "Stripe API", "--field", "key"]
).decode().strip()

Rust

let key = std::process::Command::new("clavitor-cli")
    .args(["get", "AWS Credentials", "--field", "secret_key"])
    .output()?;
let client = aws::Client::new(String::from_utf8(key.stdout)?.trim());

TypeScript / Node

import { execSync } from 'child_process';
const apiKey = execSync('clavitor-cli get "Anthropic API" --field key').toString().trim();
const client = new Anthropic({ apiKey });

C# / .NET

using System.Diagnostics;
var psi = new ProcessStartInfo("clavitor-cli") { RedirectStandardOutput = true, UseShellExecute = false };
psi.ArgumentList.Add("get");
psi.ArgumentList.Add("Stripe API");
psi.ArgumentList.Add("--field");
psi.ArgumentList.Add("key");
var key = Process.Start(psi)!.StandardOutput.ReadToEnd().Trim();
var client = new StripeClient(key);

PowerShell

# Single value — pipe or use directly
$key = clavitor-cli get "AWS Credentials" --field secret_key
Set-AWSCredential -AccessKey $env:AWS_ACCESS_KEY -SecretKey $key

# Or use the proxy — no secrets in the script at all
$env:HTTPS_PROXY = "http://localhost:1983"
Invoke-RestMethod -Uri "https://api.openai.com/v1/models" `
  -Headers @{ Authorization = "Bearer clavitor://OpenAI/key" }

Java

import java.nio.charset.StandardCharsets;

Process p = new ProcessBuilder("clavitor-cli", "get", "Stripe API", "--field", "key").start();
String key = new String(p.getInputStream().readAllBytes(), StandardCharsets.UTF_8).trim();
Stripe.apiKey = key;

Rendu de configuration

Stockez vos configurations. Pas vos secrets.

clavitor-cli render scanne n'importe quel fichier à la recherche de références clavitor://entry/field, résout chacune par rapport au coffre-fort, et affiche le résultat. Le modèle est sûr à stocker n'importe où. La configuration résolue vit dans un pipe. Les secrets ne touchent jamais le disque.

# Template (safe to store anywhere)
$ cat app.config.json
{"api_key": "clavitor://OpenRouter API/key", "db": "clavitor://Prod DB/password"}

# Resolved (piped to application, never on disk)
$ clavitor-cli render app.config.json
{"api_key": "sk-or-v1-abc123...", "db": "hunter2"}

Fonctionne avec JSON, YAML, TOML, .env, ou tout fichier texte. S'il contient clavitor://, il est résolu.

Plus de guides d'intégration

Infrastructure

Docker, Kubernetes, Terraform, Ansible, GitHub Actions, GitLab CI, SSH. Zéro secret dans la configuration, zéro secret dans les logs.

Guide d'infrastructure →

Agents IA

Claude Code, Codex, OpenClaw, Hermes, CrewAI, LangChain. Jetons à portée limitée, pistes d'audit, verrouillage automatique.

Guide des agents →

Outils MSP

PowerShell, Datto RMM, N-able, ConnectWise Automate. Émission d'identifiants pour votre base de clients.

Guide MSP →

Le modèle est toujours le même.

Un appel CLI, n'importe quel contexte. La portée de l'agent détermine ce qu'il peut voir. Le niveau détermine ce qu'il peut déchiffrer. Le journal d'audit enregistre chaque accès.

Commencer gratuitement