REST API v1
Des liens à usage unique depuis votre code.
Créez des secrets et des demandes depuis votre application, votre helpdesk ou un script. L’API est disponible avec les forfaits Pro et Pro Plus.
Authentification
Créez une clé API dans Mon compte → API. Envoyez-la dans l’en-tête Authorization comme jeton Bearer. Toutes les requêtes passent par HTTPS.
Authorization: Bearer kx_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
GET https://kriptano.com/api/v1/me
La limite de requêtes dépend du forfait (Pro 60/min, Pro Plus 300/min). Les secrets créés sont décomptés du quota mensuel du forfait.
Créer un secret
Le plus simple : envoyez le texte en clair via HTTPS – le serveur le chiffre avec le même algorithme que le navigateur, ne conserve pas la clé et renvoie le lien complet avec la clé.
curl -X POST https://kriptano.com/api/v1/secrets \
-H "Authorization: Bearer $KRIPTANO_KEY" \
-H "Content-Type: application/json" \
-d '{
"secret": "User: anna\nPassword: Gx7!pQ2m",
"expires": 604800,
"views": 1,
"passphrase": "",
"label": "Hosting – client Smith",
"notify": true
}'
Réponse (201) :
{
"id": "7GkQ2mPzr9XtWbHa",
"url": "https://kriptano.com/s/7GkQ2mPzr9XtWbHa/#k9Xv3…Qe1s",
"status": "active",
"views": 0,
"max_views": 1,
"expires_at": "2026-11-13T09:00:00+00:00"
}
| Champ | Description |
|---|---|
secret | Texte secret (jusqu’à ~90 000 caractères). |
files | Facultatif : [{"name","type","data"(base64)}] – pièces jointes, si le forfait les permet. |
expires | Durée de vie en secondes : 3600, 86400, 259200, 604800, 1209600, 2592000, 7776000, 15552000, 31536000 (dans la limite du forfait). |
views | Nombre d’ouvertures (1 par défaut). |
passphrase | Facultatif : phrase secrète supplémentaire que le destinataire doit saisir. |
label | Libellé interne (visible par vous seul ; n’y mettez pas de données secrètes). |
notify | true = notification par e-mail à l’ouverture du secret. |
uploads | Facultatif : [{"id","token"}] – pièces jointes volumineuses déjà envoyées (voir Pièces jointes volumineuses) ; uniquement avec ciphertext. |
deliver_to | Facultatif (Pro, Pro Plus) : jusqu’à 5 adresses auxquelles Kriptano envoie aussitôt le lien par e-mail. Fonctionne lorsque vous envoyez le texte en clair (secret). |
deliver_note | Facultatif : court message au destinataire (500 caractères max., sans HTML). N’y mettez pas de données confidentielles – le message n’est pas chiffré. |
Pour un zero-knowledge complet, chiffrez de votre côté (section suivante) – le serveur ne voit alors jamais le texte en clair ni la clé.
Générateur de mots de passe
GET ou POST /password renvoie des mots de passe, phrases de passe ou codes PIN aléatoires. Fonctionne avec tous les forfaits : sans clé API (limité par adresse IP) ou avec une clé sur Pro et Pro Plus (limite de votre forfait). Rien n’est stocké ni journalisé ; la réponse comporte Cache-Control: no-store. Pour une confidentialité maximale, générez dans le navigateur sur la page Générateur de mot de passe.
curl "https://kriptano.com/api/v1/password?length=20&count=3"
curl "https://kriptano.com/api/v1/password?type=passphrase&words=6&separator=-&capitalize=first&wordlist=fr&format=text"
Réponse (201) :
{
"type": "password",
"passwords": ["q7#Vt9…", "…", "…"],
"password": "q7#Vt9…",
"length": 20,
"entropy_bits": 131.1,
"strength": "very_strong",
"charset_size": 94
}
| Champ | Description |
|---|---|
type | password (par défaut), passphrase, pin ou pronounceable. |
length | Longueur : password 4–128 (20), pin 4–12 (6), pronounceable 6–64 (18). |
count | Combien générer à la fois : 1–100. |
lowercase, uppercase, numbers, symbols | Jeux de caractères (true/false ; tous activés par défaut). Au moins un caractère de chaque jeu activé. |
symbol_set, extended_symbols, exclude, exclude_similar | Votre propre liste de symboles, symboles étendus, caractères à exclure, sans caractères semblables (I l 1 | O 0 o). |
min_numbers, min_symbols, start_with_letter | Minimum de chiffres et de symboles (1 par défaut), premier caractère une lettre. |
words, separator, capitalize, include_number, include_symbol, wordlist | Phrase de passe : 3–20 mots, séparateur (- . _ space none digit symbol), capitalize (none, first, upper, random), chiffre et symbole, liste de mots en, de, fr, it, es, bcms ou sl. |
format | json (par défaut) ou text – un mot de passe par ligne. |
Générer et envoyer en un seul appel : "generate" au lieu de "secret" dans POST /secrets (Pro, Pro Plus). Le serveur crée le mot de passe, le chiffre comme secret à usage unique et renvoie le lien et le mot de passe (sauf "return_password": false).
curl -X POST https://kriptano.com/api/v1/secrets \
-H "Authorization: Bearer $KRIPTANO_KEY" \
-H "Content-Type: application/json" \
-d '{ "generate": { "type": "password", "length": 24 }, "expires": 86400, "views": 1, "deliver_to": ["anna@client.com"] }'
→ { "id": "…", "url": "https://kriptano.com/s/…#…", "password": "…", "status": "active", … }
Limites sans clé : 30 requêtes par minute et 1 000 par jour par adresse IP (HTTP 429 en cas de dépassement). Avec une clé : 60 (Pro) ou 300 (Pro Plus) par minute.
Chiffrer de votre côté
Format : AES-256-GCM, clé de 32 octets, IV de 12 octets, texte chiffré = "v1." + base64url(IV) + "." + base64url(texte chiffré+tag). Le contenu est un JSON {"v":1,"t":"texte"}. Le jeton « auth » = base64url(SHA-256(clé ‖ "kriptano-auth")). Recommandé : le champ « link » = base64url(SHA-256(clé ‖ "kriptano-link")) – preuve de possession du lien ; sans lui, une phrase secrète erronée consomme des tentatives même pour qui ne connaît que l’identifiant.
// Node.js 18+ / browser (Web Crypto)
const te = new TextEncoder();
const b64u = (b) => Buffer.from(b).toString('base64url');
const raw = crypto.getRandomValues(new Uint8Array(32)); // key – stays with you
const iv = crypto.getRandomValues(new Uint8Array(12));
const key = await crypto.subtle.importKey('raw', raw, 'AES-GCM', false, ['encrypt']);
const body = te.encode(JSON.stringify({ v: 1, t: 'Password: Gx7!pQ2m' }));
const ct = new Uint8Array(await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, key, body));
const auth = b64u(new Uint8Array(await crypto.subtle.digest('SHA-256',
new Uint8Array([...raw, ...te.encode('kriptano-auth')]))));
const res = await fetch('https://kriptano.com/api/v1/secrets', {
method: 'POST',
headers: { Authorization: `Bearer ${process.env.KRIPTANO_KEY}`, 'Content-Type': 'application/json' },
body: JSON.stringify({ ciphertext: `v1.${b64u(iv)}.${b64u(ct)}`, auth, expires: 86400, views: 1 })
}).then(r => r.json());
console.log(res.url + '#' + b64u(raw)); // link for the recipient
Avec une phrase secrète : clé finale = PBKDF2-SHA256(phrase, sel = clé du lien, 600 000 itérations, 32 octets) ; utilisez-la pour chiffrer et calculer « auth », et ajoutez "passphrase": true, "kdf": 600000 à la requête.
Liste, statut et suppression
GET https://kriptano.com/api/v1/secrets?status=active&page=1&per_page=25
GET https://kriptano.com/api/v1/secrets/{id}
DELETE https://kriptano.com/api/v1/secrets/{id}
La réponse ne contient que des métadonnées (statut, nombre d’ouvertures, dates) – jamais le contenu. Le nombre total figure dans l’en-tête X-Total-Count.
<?php
$ch = curl_init( 'https://kriptano.com/api/v1/secrets' );
curl_setopt_array( $ch, [
CURLOPT_POST => true,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => [ 'Authorization: Bearer ' . getenv( 'KRIPTANO_KEY' ), 'Content-Type: application/json' ],
CURLOPT_POSTFIELDS => json_encode( [ 'secret' => 'PIN: 4821', 'expires' => 3600 ] ),
] );
$res = json_decode( curl_exec( $ch ), true );
echo $res['url'];
Pièces jointes volumineuses (jusqu’à 10 Go)
Les petites pièces jointes peuvent être envoyées dans le champ files (base64, jusqu’à 25 Mo, chiffrées par le serveur). Les fichiers plus volumineux sont chiffrés de votre côté par fragments et envoyés directement vers le stockage via des liens signés – le serveur Kriptano ne voit jamais le contenu ni la clé. Si la connexion est interrompue, demandez de nouveaux liens uniquement pour les fragments manquants.
POST https://kriptano.com/kx-api/uploads (Authorization: Bearer kx_live_…)
{ "files": [ { "size": 734003200 } ] }
→ { "chunk": 16777216, "tag": 16, "ttl": 10800,
"uploads": [ { "id": "…", "token": "…", "parts": 44, "urls": [ "https://…", … ] } ] }
PUT urls[n-1] ← encrypted chunk n (chunk + 16 B; the last one may be shorter)
POST https://kriptano.com/kx-api/uploads/{id}/urls { "token": "…", "parts": [7, 8] } (new links)
POST https://kriptano.com/kx-api/uploads/{id}/complete { "token": "…" }
POST https://kriptano.com/api/v1/secrets
{ "ciphertext": "v1.…", "auth": "…", "uploads": [ { "id": "…", "token": "…" } ] }
Format : chaque fragment est chiffré en AES-256-GCM avec la clé du fichier (256 bits), nonce = 3 octets nuls ‖ index du fragment (64 bits, big-endian) ‖ 1 octet (1 pour le dernier fragment), AAD = « kriptano-file-v1 ». La clé et les données du fichier (id, nom, type, taille, taille de fragment) vont dans le contenu chiffré du secret sous la forme {"f":[{"v":2,"id","n","m","s","k","c"}]}. Implémentation de référence : assets/js/files.js.
Envoi par e-mail
Avec deliver_to, Kriptano envoie lui-même le lien au destinataire – depuis votre domaine e-mail ou via votre serveur SMTP (Pro Plus), sinon depuis une adresse Kriptano. La clé figure dans le lien : l’e-mail n’est donc envoyé que si le serveur la connaît (texte en clair) ; pour les secrets chiffrés de votre côté, envoyez le lien vous-même. La réponse contient delivered et, en cas d’échec, delivery_error – le secret est créé dans tous les cas.
POST https://kriptano.com/api/v1/secrets
{ "secret": "VPN: user / password", "expires": 86400,
"deliver_to": [ "anna@client.com" ], "deliver_note": "Access for the new office." }
→ { "id": "…", "url": "https://…/s/…#…", "delivered": true, … }
POST https://kriptano.com/api/v1/requests
{ "label": "FTP access", "public_key": "…", "deliver_to": [ "mark@client.com" ] }
Demandes de secret
Une demande chiffre les réponses avec votre clé publique RSA. Vous générez vous-même la paire de clés ; la clé privée reste chez vous et sert à déchiffrer les réponses.
POST https://kriptano.com/api/v1/requests
{ "label": "FTP access", "instructions": "Please send the host, username and password.",
"public_key": "<SPKI RSA-OAEP 2048, base64url>", "expires_days": 14, "max_responses": 1 }
GET https://kriptano.com/api/v1/requests/{id}/responses
→ [ { "id": "…", "ciphertext": "r1.<RSA-OAEP(AES key)>.<iv>.<AES-GCM ciphertext>", "created_at": "…" } ]
Journal d’audit
Les événements de votre compte (Pro, Pro Plus) pour un SIEM ou un archivage : période (from, to), type, jusqu’à 500 par page. Le journal ne contient jamais le contenu des secrets, ni les clés ou les liens ; le pays provient d’une base de géolocalisation locale. Mêmes données que le CSV : Mon compte → Journal d’audit → Exporter en CSV.
GET https://kriptano.com/api/v1/log?from=2026-11-01&to=2026-11-30&type=secret_viewed&page=1&per_page=100
→ [ { "id": 812, "time": "2026-11-08T09:14:02+00:00", "type": "secret_viewed", "event": "Secret opened",
"user": null, "country": "HR", "object_id": "…", "message": "…" } ] (X-Total-Count: 37)
Webhooks
Pro et Pro Plus : ajoutez une URL HTTPS dans Mon compte → Webhooks et choisissez les événements. Kriptano envoie un POST JSON juste après l’événement ; le contenu du secret, la clé et le lien ne sont jamais inclus (le serveur ne les possède pas).
Événements : secret.created, secret.viewed, secret.locked, secret.deleted, secret.expired, request.created, request.answered, team.member_joined, team.member_removed, ping.
POST https://example.com/hooks/kriptano
Content-Type: application/json; charset=utf-8
Kriptano-Event: secret.viewed
Kriptano-Delivery: evt_3kT9…
Kriptano-Signature: t=1762770000,v1=5f2c…e91a
{ "id": "evt_3kT9…", "type": "secret.viewed", "created": "2026-11-10T09:14:02Z",
"data": { "secret": { "id": "Qm7x…", "label": "Hosting – client Smith", "status": "burned",
"views": 1, "max_views": 1, "has_passphrase": true, "files": false, "source": "web",
"created_at": "…", "expires_at": "…", "viewed_at": "…" },
"viewer": { "country": "HR" } } }
Vérifiez la signature : le HMAC-SHA256 de « t.body » avec le secret whsec_… doit être égal à v1, et t ne doit pas dater de plus de 5 minutes. Utilisez le corps brut de la requête (avant l’analyse JSON).
// Node.js
const crypto = require('crypto');
function verify(rawBody, header, secret) { // header = req.headers['kriptano-signature']
const p = Object.fromEntries(header.split(',').map(s => s.split('=')));
if (Math.abs(Date.now() / 1000 - Number(p.t)) > 300) return false;
const mac = crypto.createHmac('sha256', secret).update(p.t + '.' + rawBody).digest('hex');
return crypto.timingSafeEqual(Buffer.from(mac), Buffer.from(p.v1));
}
# PHP
$p = []; parse_str(str_replace(',', '&', $_SERVER['HTTP_KRIPTANO_SIGNATURE']), $p);
$ok = abs(time() - (int) $p['t']) <= 300
&& hash_equals(hash_hmac('sha256', $p['t'] . '.' . file_get_contents('php://input'), $secret), $p['v1']);
Répondez avec un statut 2xx en moins de 10 secondes. En cas d’erreur ou de délai dépassé, nous réessayons après 1 min, 5 min, 30 min, 2 h, 6 h et 12 h ; le statut 410 arrête la livraison. Après 50 échecs consécutifs, le webhook est désactivé. Un même événement peut arriver deux fois – utilisez le champ id (Kriptano-Delivery) pour dédoublonner.
Erreurs
| HTTP | Description |
|---|---|
| 400 | Données non valides (message dans le champ "message"). |
| 401 | Clé API manquante ou non valide. |
| 402 | Le forfait n’inclut pas l’API. |
| 403 | Limite du forfait dépassée (durée de vie, nombre d’ouvertures, pièces jointes). |
| 404 / 410 | Le secret n’existe pas, a été ouvert ou a expiré. |
| 413 | Le contenu est trop volumineux. |
| 429 | Trop de requêtes ou quota mensuel épuisé. |
Intégrations
Quand utiliser l’API REST
L’intégration s’adresse aux équipes qui envoient des mots de passe depuis leurs propres systèmes : un helpdesk qui envoie un mot de passe temporaire, un CRM qui transmet des identifiants à un nouveau client ou un script qui envoie un lien à usage unique après la mise en service d’un serveur.
Vous pouvez chiffrer le secret vous-même (Web Crypto, AES-256-GCM – voir la documentation MDN) et n’envoyer que le texte chiffré, ou envoyer le texte en clair via HTTPS : le serveur le chiffre au même format et ne conserve jamais la clé.
Créez une clé API dans Mon compte avec les forfaits Pro et Pro Plus (comparer les forfaits). Les secrets créés sont décomptés du quota mensuel du forfait.
La réponse contient le lien avec la clé après le #, la date d’expiration et le nombre d’ouvertures restantes. Vous transmettez le lien à l’utilisateur comme n’importe quel autre – par e-mail, message ou dans l’interface de votre application. Lorsque l’utilisateur ouvre le secret, le texte chiffré est supprimé et votre liste de secrets l’indique comme ouvert.
Une demande de secret fonctionne dans l’autre sens : votre système crée un lien où le client saisit les données, et la réponse est chiffrée avec une clé publique que vous avez générée de votre côté. Les réponses restent ainsi illisibles pour tout le monde, sauf pour vous.
Saisissez le secret
Chiffré dans le navigateur
Envoyez le lien
Ouvert une fois, puis effacé