Skip to main content

Kibo Standalone Onboarding

Kibo ships either composed into a Kilimanjaro plan via @k9o/core or as a standalone secrets-management package via @k9o/kibo. The standalone path is for customers who need sovereign secrets management for an application that isn't otherwise on Kilimanjaro. The wire contract and SDK shape are identical across both paths.

Step 1Sign uporg slugjurisdictionaccount email, MFAAfter signupFirst projectprovisioned for youPlatform-Managed CEKAPI key issuedStep 2Connect@k9o/kibo SDKkey + project slugor direct HTTPSStep 3First operationsencrypt in-processstore the envelopesigned ledger entry
Onboarding runs from signup to a first encrypt, store and ledger entry, with no Kilimanjaro plan required.

1. Sign up​

Sign up at kilimanjaro.dev/kibo selecting the Kibo-standalone plan tier. No Kilimanjaro plan or project is required to start.

At signup you'll set:

  • Org slug — the URL-safe identifier that becomes your tenant subdomain (<orgSlug>.api.k9o.io).
  • Jurisdiction — the per-project key is provisioned and pinned in a customer-selectable region. The choice is immutable post-org-creation per the Regions immutability rule.
  • Account email — the operator-scope identity for sign-in. MFA enrollment is mandatory at first sign-in.

After signup, your first Kibo project provisions automatically with a Platform-Managed CEK; the API key for SDK calls is issued on the post-signup landing.

2. Connect Kibo to your stack​

Kibo is reachable from any application via the @k9o/kibo SDK or via direct HTTPS calls to <orgSlug>.api.k9o.io/@<projectSlug>/kibo/.... Install the SDK:

npm install @k9o/kibo
# or pip install k9o (module k9o.kibo), etc. for the other SDK families

Initialise with your API key + project slug:

import { createKiboClient } from '@k9o/kibo';

const kibo = createKiboClient({
baseUrl: 'https://<orgSlug>.api.k9o.io',
projectSlug: '<projectSlug>',
apiKey: process.env.K9O_API_KEY,
});

Connect Kibo to your existing infrastructure surfaces:

  • Application data plane — encrypt and decrypt PII fields, card numbers, and tokens in your own process with the module-level encrypt / decrypt functions (see Client-Side Encryption for the full input model).
  • Existing AWS / GCP / Azure deployments — set custodyMode: 'byok' when you create the project (via @k9o/core) and encrypt with posture: 'byok' against a CEK held in your AWS KMS, GCP Cloud KMS, Azure Key Vault, or HashiCorp Vault Transit instance.
  • On-prem HSM — set custodyMode: 'hyok' at project creation and encrypt with posture: 'hyok' against one of the four cloud-managed HSM paths.

3. First operations​

Encryption and decryption run in-process as the module-level encrypt / decrypt functions; the client you constructed above is the project's ZK-DEK vault, where you persist and retrieve the opaque envelopes. A first round-trip:

import { encrypt, decrypt } from '@k9o/kibo';

// Encrypt in your own process under your own KMS (posture selects BYOK/HYOK).
// See Client-Side Encryption for the full provider / posture / key_ref input model.
const { envelope } = await encrypt({ /* provider, posture, kms_cred, key_ref, plaintext, … */ });

// Store and later retrieve the opaque envelope via the project's ZK-DEK vault:
const handle = await kibo.vault.zkDeks.store({ /* StoreZkDekInput */ });
const record = await kibo.vault.zkDeks.fetch(handle.data.id);

The vault store / fetch operations emit signed entries in the project's audit ledger; view them in the Console at /vault/ledger.

The vault also holds named secrets. The example below runs their whole lifecycle from the SDK.

Create the client once

client
import { createClient, realtimeTopic } from "@k9o/core";

const k9o = createClient({
  orgSlug: "acme",
  projectSlug: "task-app",
  apiKey: process.env.K9O_API_KEY,
});

Kibo · Vault secrets lifecycle

Setup

Setup
const secrets = k9o.kibo.vault.secrets;
const name = "ex-payments-api-key";
1. Create and get
// Create. Pass the plaintext; the SDK encodes it for the wire.
const { data: created } = await secrets.create({
  name,
  value: "correct-horse-battery-staple",
  visibility: { kind: "private" },
  metadata: { owner: "billing" },
});
console.log(created.id, created.name, `v${created.version}`);

// Get: metadata only, never the value.
const { data: before } = await secrets.get(name);
console.log(`key ${before.kid}, ${before.visibility.kind}, owner ${before.metadata.owner}`);
Output · bash
sec_7Kd2mQ ex-payments-api-key v1
key kid_01j9x2, private, owner billing
  • Secret names here start with ex-. Run the tab with a project member's API key.
  • The tab creates and then deletes a secret.

4. Pricing on standalone​

The Kibo-standalone tier prices per encrypt / decrypt / sign / verify operation with stairstep volume tiers; rotation operations price separately. Custody-mode upgrades (Platform-Managed → BYOK / HYOK) are no-cost; descent transitions require the IRREVERSIBLE_ACTION_GATE attestation per Controls.

Detailed pricing lives on the pricing page.

5. Bundling into a Kilimanjaro plan later​

You can add the rest of Kilimanjaro to your org at any time. Your existing Kibo project keeps its focused Vault-mode interface; new projects you create surface the full five-mode Console — Workspace, Studio, Forge, Vault, and Admin — for data, compute, controls, and extensions alongside the same custody surface you already use in Vault. Switching between a Kibo-only project and a full-Kilimanjaro project switches the Console's chrome to match.

Your existing Kibo SDK code keeps working unchanged — the SDK and wire contract are identical between standalone-Kibo and Kibo-as-part-of-Kilimanjaro. The upgrade is a billing and plan change, not a code change.

6. See also​