REST API v1
Enlaces de un solo uso desde tu código.
Crea secretos y solicitudes desde tu propia app, tu helpdesk o un script. La API está disponible en los planes Pro y Pro Plus.
Autenticación
Crea una clave de API en Mi cuenta → API. Envíala en la cabecera Authorization como token Bearer. Todas las peticiones van por HTTPS.
Authorization: Bearer kx_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
GET https://kriptano.com/api/v1/me
El límite de peticiones depende del plan (Pro 60/min, Pro Plus 300/min). Los secretos que crees cuentan para la cuota mensual del plan.
Crear un secreto
La forma más sencilla: envía el texto en claro por HTTPS. El servidor lo cifra con el mismo algoritmo que el navegador, no guarda la clave y devuelve el enlace completo con la clave.
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
}'
Respuesta (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"
}
| Campo | Descripción |
|---|---|
secret | Texto secreto (hasta ~90.000 caracteres). |
files | Opcional: [{"name","type","data"(base64)}] – adjuntos, si el plan los permite. |
expires | Duración en segundos: 3600, 86400, 259200, 604800, 1209600, 2592000, 7776000, 15552000, 31536000 (hasta el límite del plan). |
views | Número de aperturas (por defecto 1). |
passphrase | Opcional: frase de acceso adicional que debe introducir el destinatario. |
label | Etiqueta interna (solo la ves tú; no pongas aquí datos secretos). |
notify | true = aviso por correo cuando se abra el secreto. |
uploads | Opcional: [{"id","token"}] – adjuntos grandes ya subidos (ver Adjuntos grandes); solo con ciphertext. |
deliver_to | Opcional (Pro, Pro Plus): hasta 5 direcciones a las que Kriptano envía el enlace por correo al momento. Funciona cuando envías texto en claro (secret). |
deliver_note | Opcional: un mensaje breve al destinatario (hasta 500 caracteres, sin HTML). No incluyas datos confidenciales: el mensaje no está cifrado. |
Para un zero-knowledge completo, cifra en tu lado (siguiente sección): así el servidor nunca ve ni el texto en claro ni la clave.
Generador de contraseñas
GET o POST /password devuelve contraseñas, frases de contraseña o PIN aleatorios. Funciona en todos los planes: sin clave de API (limitado por dirección IP) o con clave en Pro y Pro Plus (límite de tu plan). No se guarda ni se registra nada; la respuesta lleva Cache-Control: no-store. Para la máxima privacidad, genera en el navegador desde la página Generador de contraseñas.
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=es&format=text"
Respuesta (201):
{
"type": "password",
"passwords": ["q7#Vt9…", "…", "…"],
"password": "q7#Vt9…",
"length": 20,
"entropy_bits": 131.1,
"strength": "very_strong",
"charset_size": 94
}
| Campo | Descripción |
|---|---|
type | password (por defecto), passphrase, pin o pronounceable. |
length | Longitud: password 4–128 (20), pin 4–12 (6), pronounceable 6–64 (18). |
count | Cuántas generar a la vez: 1–100. |
lowercase, uppercase, numbers, symbols | Conjuntos de caracteres (true/false; todos activados por defecto). Al menos un carácter de cada conjunto activado. |
symbol_set, extended_symbols, exclude, exclude_similar | Tu propia lista de símbolos, símbolos extendidos, caracteres que excluir, sin caracteres parecidos (I l 1 | O 0 o). |
min_numbers, min_symbols, start_with_letter | Números y símbolos mínimos (1 por defecto), primer carácter una letra. |
words, separator, capitalize, include_number, include_symbol, wordlist | Frase de contraseña: 3–20 palabras, separador (- . _ space none digit symbol), capitalize (none, first, upper, random), número y símbolo, lista de palabras en, de, fr, it, es, bcms o sl. |
format | json (por defecto) o text: una contraseña por línea. |
Generar y enviar en una sola llamada: "generate" en lugar de "secret" en POST /secrets (Pro, Pro Plus). El servidor crea la contraseña, la cifra como secreto de un solo uso y devuelve el enlace y la contraseña (salvo "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", … }
Límites sin clave: 30 peticiones por minuto y 1.000 al día por dirección IP (HTTP 429 si se superan). Con clave: 60 (Pro) o 300 (Pro Plus) por minuto.
Cifrar en tu lado
Formato: AES-256-GCM, clave de 32 bytes, IV de 12 bytes, texto cifrado = "v1." + base64url(IV) + "." + base64url(texto cifrado+tag). El contenido es un JSON {"v":1,"t":"texto"}. El token «auth» = base64url(SHA-256(clave ‖ "kriptano-auth")). Recomendado: el campo «link» = base64url(SHA-256(clave ‖ "kriptano-link")) – prueba de posesión del enlace; sin él, una frase de acceso incorrecta consume intentos incluso para quien solo conoce el ID.
// 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
Con frase de acceso adicional: clave final = PBKDF2-SHA256(frase, sal = clave del enlace, 600.000 iteraciones, 32 bytes); úsala para cifrar y calcular «auth», y añade "passphrase": true, "kdf": 600000 a la petición.
Lista, estado y borrado
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 respuesta solo contiene metadatos (estado, número de aperturas, fechas), nunca el contenido. El total está en la cabecera 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'];
Adjuntos grandes (hasta 10 GB)
Los adjuntos pequeños pueden ir en el campo files (base64, hasta 25 MB, cifrados por el servidor). Los archivos grandes se cifran en tu lado por bloques y se envían directamente al almacenamiento mediante enlaces firmados: el servidor de Kriptano nunca ve ni el contenido ni la clave. Si se corta la conexión, pide enlaces nuevos solo para los bloques que faltan.
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": "…" } ] }
Formato: cada bloque es AES-256-GCM con la clave del archivo (256 bits), nonce = 3 bytes a cero ‖ índice del bloque (64 bits, big-endian) ‖ 1 byte (1 para el último bloque), AAD = «kriptano-file-v1». La clave y los datos del archivo (id, nombre, tipo, tamaño, tamaño de bloque) van en el contenido cifrado del secreto como {"f":[{"v":2,"id","n","m","s","k","c"}]}. Implementación de referencia: assets/js/files.js.
Envío por correo
Con deliver_to, Kriptano envía el enlace al destinatario por sí mismo: desde tu dominio de correo o a través de tu servidor SMTP (Pro Plus), o si no desde una dirección de Kriptano. La clave está en el enlace, así que el correo solo se envía cuando el servidor la conoce (texto en claro); para secretos cifrados en tu lado, envía tú el enlace. La respuesta contiene delivered y, si el envío falla, delivery_error: el secreto se crea igualmente.
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" ] }
Solicitudes de secretos
Una solicitud cifra las respuestas con tu clave pública RSA. El par de claves lo generas tú; la clave privada se queda contigo y la usas para descifrar las respuestas.
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": "…" } ]
Registro de auditoría
Los eventos de tu cuenta (Pro, Pro Plus) para un SIEM o archivo: periodo (from, to), tipo, hasta 500 por página. El registro nunca contiene el contenido de los secretos, ni claves ni enlaces; el país procede de una base de geolocalización local. Los mismos datos que el CSV: Mi cuenta → Registro de auditoría → Exportar 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 y Pro Plus: añade una URL HTTPS en Mi cuenta → Webhooks y elige los eventos. Kriptano envía un POST JSON justo después del evento; nunca se incluyen el contenido del secreto, la clave ni el enlace (el servidor no los tiene).
Eventos: 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" } } }
Verifica la firma: el HMAC-SHA256 de «t.body» con el secreto whsec_… debe ser igual a v1, y t no debe tener más de 5 minutos. Usa el cuerpo bruto de la petición (antes de analizar el 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']);
Responde con un estado 2xx en menos de 10 segundos. Si hay errores o se agota el tiempo, reintentamos tras 1 min, 5 min, 30 min, 2 h, 6 h y 12 h; el estado 410 detiene las entregas. Tras 50 fallos seguidos, el webhook se desactiva. Un mismo evento puede llegar dos veces: usa el campo id (Kriptano-Delivery) para evitar duplicados.
Errores
| HTTP | Descripción |
|---|---|
| 400 | Datos no válidos (mensaje en el campo "message"). |
| 401 | Falta la clave de API o no es válida. |
| 402 | El plan no incluye la API. |
| 403 | Límite del plan superado (duración, número de aperturas, adjuntos). |
| 404 / 410 | El secreto no existe, ya se ha abierto o ha caducado. |
| 413 | El contenido es demasiado grande. |
| 429 | Demasiadas peticiones o cuota mensual agotada. |
Integraciones
Cuándo usar la API REST
La integración está pensada para equipos que envían contraseñas desde sus propios sistemas: un helpdesk que envía una contraseña temporal, un CRM que entrega credenciales a un cliente nuevo o un script que envía un enlace de un solo uso tras poner en marcha un servidor.
Puedes cifrar tú el secreto (Web Crypto, AES-256-GCM; consulta la documentación de MDN) y enviar solo el texto cifrado, o enviar el texto en claro por HTTPS: el servidor lo cifra con el mismo formato y nunca guarda la clave.
Crea una clave de API en Mi cuenta con los planes Pro y Pro Plus (compara los planes). Los secretos que crees cuentan para la cuota mensual del plan.
La respuesta contiene el enlace con la clave después del #, la caducidad y el número de aperturas restantes. Le pasas el enlace al usuario como cualquier otro: por correo, mensaje o en la interfaz de tu app. Cuando el usuario abre el secreto, el texto cifrado se borra y tu lista de secretos lo muestra como abierto.
Una solicitud de secreto funciona al revés: tu sistema crea un enlace donde el cliente introduce los datos y la respuesta se cifra con una clave pública que generaste tú. Así las respuestas son ilegibles para todos menos para ti.
Escribe el secreto
Cifrado en el navegador
Envía el enlace
Se abre una vez y desaparece