Skip to main content

Billing

You pay for a tier, drawn from your prepaid service credit, and that's almost the whole picture. Each tier comes with allowances across the work the platform does for you — compute, persistence, egress, governed operations, vault operations — and within your allowance the platform just runs. Identity (MAU) and API requests are unlimited on every paid tier — identity is a right, not a tax, and you shouldn't pay for the request count of operations you can't meaningfully control.

When you bump up against an allowance, the platform's default behavior is throttle and prompt you to upgrade — no surprise bill. If you'd rather burst elastic on a specific dimension than be throttled, you opt into Headroom on that dimension — pay-as-you-go above your allowance, your choice. Per-dimension granularity means you control which dimensions can affect your bill and which can't.

The full reference, including the per-dimension surface shape, the meta.cost block, and the Gate MAU model, is at /specifications/billing. The canonical rate card lives on the pricing page. This guide is the mental model.

1. The model at a glance​

Three moving parts:

  1. Your tier — Base Camp ($0), Ascent, Ridge, Summit. Each tier includes monthly allowances across all the metered dimensions plus the unlimited wedges (MAU + API requests).
  2. Headroom — an opt-in toggle, per dimension, that lets a tenant exceed an allowance without throttling. Default is off; you decide which dimensions are allowed to bill elastic.
  3. The unlimited wedges — Monthly Active Users (MAU) and API request count are never billed on any paid tier. They participate in throttling and observability, but not pricing.

If you stay inside your allowances, your bill is your tier's price, drawn from your balance. If you exceed an allowance with Headroom off, you get throttled and prompted to upgrade — predictable. If you exceed an allowance with Headroom on, you pay the per-unit Headroom rate for that dimension above the allowance. Sparse all the way: $0 on any dimension until you actually incur it.

Usageon one dimensionAllowanceincluded in your tierWithin allowancethe platform just runs;the bill is your tier priceOver allowance, Headroom offthrottled and prompted to upgrade;no surprise billOver allowance, Headroom onyou pay the per-unit Headroom rateabove the allowance
Headroom is the per-dimension switch between being throttled and paying above the allowance.

2. What you're billed on​

When Headroom takes you above an allowance, these are the dimensions that can show up on your bill:

DimensionWhat it metersNotes
Governed OperationsDecision commits — a governed action crossing the Keep enforcement boundary, IRREVERSIBLE_ACTION_GATE redemptions, workflow step boundariesFlat rate across tiers — the unit is a value metric (governed irreversible action), not a nudge lever
Persistence — Elastic DatabaseManaged ACID/indexed/vector store; the transactional layer you reach through the data planeSeparate allowance from object storage; managed-store rates
Persistence — Object StorageBulk files and blobs at object-storage ratesSeparate allowance from Elastic Database; bulk-storage rates
EgressBytes leaving the platform; zone-tagged (see Zoned egress)Ingress is free
Vault operationsCustomer-invoked cryptography — encrypt, decrypt, sign, verify, rotate, fetchCustomer-controlled crypto only (BYOK/HYOK or the Vault Secrets API); baseline platform encryption of your secrets at rest is never billed
Sandbox computeSandbox CPU-ms of active execution, for anything that runs in the sandbox (functions, extensions, workflows, Warden)Drawn from the allowance that comes with your capacity packs first. Default = throttle on allowance exhaustion; bills only if you opt into Headroom on this dimension. Per-invocation caps don't lift with Headroom — see Compute model and acceptable use

Two dimensions are unlimited on every paid tier and never billed: API requests (apiCalls) and Monthly Active Users (MAU). They're rate-limited / throttled for fair-use, but they don't appear on the bill.

3. Zoned egress​

Egress has three pricing zones:

  • Intra-region — traffic within the same region. Lowest rate.
  • Inter-region — traffic between regions inside the same sovereignty jurisdiction.
  • Sovereignty-boundary — traffic that crosses a jurisdiction boundary (e.g., EU → US). Highest rate — this is the cost of running on a sovereignty-aware data plane.

The lever is to region-pin tighter, hydrate caches at the edge, and design subscription filters so deliveries don't cross zones they don't need to. The meta.cost.egress block carries the zone so your self-attribution reflects which slice accrued.

4. The persistence split​

Persistence isn't one rate — it's two pricing classes with separate allowances:

  • Elastic Database — the managed ACID / indexed / vector store you reach through the data plane. Row writes, vector-index growth, the transactional store backing your collections.
  • Object Storage — bulk file and blob storage, at object-storage rates.

The meta.cost.storageGbMonth field carries a class discriminator so your self-attribution reflects which storage class accrued. The optimization levers are different too: lifecycle policies for ephemeral object data; compaction and TTL discipline for Elastic Database.

5. Read meta.cost to self-attribute​

Every response carries a meta.cost surface for the dimensions the operation incurred. Absent keys mean zero on that dimension — sparse by design. A meta.cost block of { "apiCalls": 1 } tells you the operation cost only an API call and a response-payload egress slice; no compute, no governed operation, no vault op.

This is the self-attribution layer. meta.cost carries every metered dimension — including the ones that aren't billed (apiCalls, baseline counts) — for observability and debugging. Application code can log it per request, aggregate by route, and see the dimension breakdown without waiting for the period invoice:

import type { MetaContext } from '@k9o/core';

const { data, meta } = await k9o.from('orders').insert({ total: 1200 });

logger.info('cost', {
route: 'POST /orders',
requestId: (meta.context as MetaContext).requestId,
cost: meta.cost, // { apiCalls, cpuMs, egress, vaultOps, storageGbMonth, ... }
});

The technical surface always carries the full six-dimension shape; the pricing surface (what gets billed) is the subset above. Reading meta.cost is how you find dimension-dominant routes before they show up on a bill.

meta.context carries the attribution dimension — which user, token, or extension to attribute work to — separately from meta.cost (the quantification dimension).

6. Operation semantics, not auth context​

Metering follows the operation, not who called it. A governed-operation emission is a governed operation whether the function authenticated as a human user, a service token, or the anonymous API key. A service_role token does not get a metering discount for committing decisions.

Cost analysis stays consistent across deployment shapes: the same operation invoked from a frontend, a backend service, an extension plugin, or a CI/CD pipeline costs the same on every dimension.

7. Compute model and acceptable use​

Anything that runs in the sandbox, or calls something that does, is metered in sandbox CPU-ms: functions, extensions (agents ship as extensions), workflows and Warden. Usage is drawn from the allowance first. When the allowance is exhausted, the default is throttle and prompt for upgrade — no surprise bill. Opting into Headroom on the compute dimension lets work continue, billed per million CPU-ms above the allowance. Invocations are counted and reported but never priced per request.

The allowance rides on the capacity pack: 100M CPU-ms a month per pack, wherever the pack sits, so each add-on pack raises it.

PlanPacksSandbox CPU-ms a month
Base Campnone10M
Ascent1100M
Ridge5500M
Summit202B
Warden Standard / Pro1 / 5100M / 500M
Each add-on pack+1+100M
Enterprisecontractcontract

Your invoice and dashboard show usage against the allowance: how much is drawn and any Headroom charge. Rates are on the pricing page.

Per-invocation CPU caps don't lift, ever. Sandbox invocations are bounded at 60 s standard, up to 15 minutes. These caps are an architectural property of how the substrate is partitioned (Firecracker VM pools for the sandbox), not a billing knob.

That cap shape makes certain workloads structurally out-of-scope on Cloud self-serve: running model-training, batch ML compute, or crypto mining as a primary workload is currently out of scope on Cloud self-serve, regardless of Headroom budget. Training steps want minutes-to-hours of contiguous CPU per iteration; chaining short invocations is order-of-magnitude more expensive in wall-clock than renting the right compute elsewhere; and a single tenant monopolizing a reserved-pool VM would starve others in the same pool. Enforcement is telemetry-driven fair-use — anomalies route to a sales conversation, not a bill.

If you do need dedicated capacity for ML, training, or any workload class, the Sovereign Control and Private Perimeter deployment models carry dedicated compute by contract.

8. Users are free — you pay for the work they do​

Gate (the platform's Identity-Aware Kernel) is metered on a Monthly Active Users (MAU) headline — a Free-tier ceiling of 50,000, unlimited on every paid tier. MAU never appears in meta.cost and never appears on a paid invoice.

This is intentional and load-bearing: identity is a right, not a tax. A small team validating product-market fit fits comfortably within the 50K Free-tier ceiling; a scaling business pays for the work end-users generate (governed operations, storage, egress, vault ops), not for sign-ups.

Gate's full surface is available to every project on every plan: the core auth surface (gate.signUp, gate.signIn, MFA, passkeys, social, password flows, admin tools) and the federation primitives (SAML, SCIM, IdP federation).

9. Estimate and verify​

Two reads tell you the running picture:

  • GET <orgSlug>.api.k9o.io/@<projectSlug>/billing/cost — current-period dimension breakdown plus an estimatedTotal.
  • GET <orgSlug>.api.k9o.io/billing/cost — same shape aggregated across all projects in the org.

Historical periods (sealed, with the final invoiced amount) are available via the corresponding /history endpoints. Retention is 7 years — cost data is accounting-grade.

The estimate runs against current-period tier rates; the final invoice closes at period end. Reconciliation is the same shape as the running estimate — no surprises between the running surface and the final invoice unless your tier or Headroom toggles changed mid-period.

See also​

  • Billing reference — the per-dimension surface shape, the meta.cost field set, TIER_CAP_HIT cost fields, the Gate MAU model, and the cost-data API.
  • Prepaid service credit — how the balance is topped up, drawn, and refunded.
  • Pricing page — the canonical rate card.
  • Conventions — the response-envelope shape meta.cost sits inside.
  • Compute — CPU-ms, governed-operation emission rules.