Ir al contenido
ES

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.

Crear una clave de API Planes con API

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"
}
CampoDescripción
secretTexto secreto (hasta ~90.000 caracteres).
filesOpcional: [{"name","type","data"(base64)}] – adjuntos, si el plan los permite.
expiresDuración en segundos: 3600, 86400, 259200, 604800, 1209600, 2592000, 7776000, 15552000, 31536000 (hasta el límite del plan).
viewsNúmero de aperturas (por defecto 1).
passphraseOpcional: frase de acceso adicional que debe introducir el destinatario.
labelEtiqueta interna (solo la ves tú; no pongas aquí datos secretos).
notifytrue = aviso por correo cuando se abra el secreto.
uploadsOpcional: [{"id","token"}] – adjuntos grandes ya subidos (ver Adjuntos grandes); solo con ciphertext.
deliver_toOpcional (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_noteOpcional: 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
}
CampoDescripción
typepassword (por defecto), passphrase, pin o pronounceable.
lengthLongitud: password 4–128 (20), pin 4–12 (6), pronounceable 6–64 (18).
countCuántas generar a la vez: 1–100.
lowercase, uppercase, numbers, symbolsConjuntos de caracteres (true/false; todos activados por defecto). Al menos un carácter de cada conjunto activado.
symbol_set, extended_symbols, exclude, exclude_similarTu 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_letterNúmeros y símbolos mínimos (1 por defecto), primer carácter una letra.
words, separator, capitalize, include_number, include_symbol, wordlistFrase 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.
formatjson (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

HTTPDescripción
400Datos no válidos (mensaje en el campo "message").
401Falta la clave de API o no es válida.
402El plan no incluye la API.
403Límite del plan superado (duración, número de aperturas, adjuntos).
404 / 410El secreto no existe, ya se ha abierto o ha caducado.
413El contenido es demasiado grande.
429Demasiadas 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.

  1. API REST de Kriptano: secreto, cifrado, enlace y apertura únicaEscribe el secreto
  2. Cifrado en el navegadorCifrado en el navegador
  3. Envía el enlaceEnvía el enlace
  4. Se abre una vez y desapareceSe abre una vez y desaparece