Skip to content

Core · every plan

A description generated from the thing it describes

Enclessa exposes an HTTP API described by an OpenAPI 3.1 document that is generated from the server rather than written alongside it, with a continuous-integration job that fails the build if the two ever disagree. Access is by token: a personal access token that acts as you, or a bot token that acts as itself. Every token carries scopes drawn from a closed vocabulary, must expire within a year, and is stored only as a hash of itself.

Open betaThe platform is being built in the open, so parts of it are not there yet, behaviour changes between releases, and no availability figure is committed while it is in beta. What is still being built.

At a glance

Description
OpenAPI 3.1, generated from the server
Drift
A CI job fails the build if the document and the code disagree
Scopes
A closed vocabulary; an unknown scope is refused, not ignored
Expiry
Mandatory, one to 365 days, ninety by default
Storage
A hash of the token, never the token
Reach
Only operations explicitly opened to tokens

What does a token let me do?

Exactly what its scopes say, on the subset of operations that have been explicitly opened to token authentication. Everything else answers 401 to a token, however senior its owner is. The scope vocabulary is closed: reading channels, reading and writing messages, adding reactions, reading users, and reading and writing tasks. Asking for a scope that is not in the list is refused rather than quietly dropped.

  • channels:read, messages:read, messages:write, reactions:write, users:read, tasks:read, tasks:write
  • An unrecognised scope is an error, not an ignored field
  • A token reaches a deliberately narrow slice of the surface; the rest answers 401
  • Scopes narrow what an account can do — they never widen it

How do tokens expire and get revoked?

Every token has an expiry, because a policy with a “never” option is not a policy. You choose between one and 365 days, and ninety is the default. Expiry, revocation and the owner’s status are resolved together in a single query, so there is no gap between deactivating an account and its credentials going dead.

  • Anyone can mint and revoke their own personal access tokens from account settings
  • An administrator mints and revokes bot tokens from the console
  • The value is shown once; only its hash is stored
  • Deactivating the owner kills the token at the next call, without a separate revocation step

How do I know the documentation matches the software?

Because it is not documentation in the usual sense. The OpenAPI document is generated from the server’s own route definitions and committed to the repository, and a continuous-integration job regenerates it on every change and fails the build on any difference. A description that cannot drift is worth more than one that is merely thorough.

  • Generated from the code, not maintained beside it
  • A drift check in CI, so the two cannot diverge quietly
  • A TypeScript client is generated from the same document
  • The same document drives a generated cross-organisation probe suite that fails the build if isolation regresses

What this does not do

  • There is no hosted API reference site and no published client library yet. The generated TypeScript client lives in the repository rather than on a package registry.
  • A token reaches only the operations that have been explicitly opened to it, which is a small part of the whole surface. This will grow deliberately rather than all at once.
  • There is no OAuth2 authorisation flow, so a third party cannot ask a user for access to their Enclessa account. Tokens are minted by their owner and pasted into your own software.
  • There are no webhooks out of the platform and no event stream for integrators. To learn that something happened, you poll.
  • Nothing in the API can read an end-to-end encrypted room. The server holds ciphertext, and no scope changes that.
  • Rate limits are per organisation by class of request, not per token. A busy integration shares a budget with the people using the product.

Related

Questions

The API: common questions

Does Enclessa have an API?

Yes. Enclessa exposes an HTTP API described by an OpenAPI 3.1 document that is generated from the server itself, with a continuous-integration job that fails the build if the document and the code ever disagree.

How do I authenticate against the Enclessa API?

With an access token. Any member can mint a personal access token from account settings, and an administrator can mint a token for a bot account. Each token carries scopes from a closed vocabulary and must expire within a year.

Do Enclessa API tokens expire?

Always. Expiry is mandatory, between one and 365 days, and defaults to ninety. There is no non-expiring token, because a policy with a “never” option is not one.

Is there an Enclessa SDK?

A TypeScript client is generated from the OpenAPI document, but it is not yet published to a package registry, and there is no hosted API reference site. Today you generate a client from the document or call the endpoints directly.

Can I build a third-party app on the Enclessa API?

You can build software that uses the API with a token you have been given, but there is no OAuth2 flow, so your software cannot ask another organisation’s users for access. There is also no app marketplace to list it in.

Encrypted collaboration, hosted in Europe.

Create a workspace in a couple of minutes. It is yours at your-team.enclessa.app, hosted in the European Union, with encrypted direct messages from the first one you send.

Open beta. Free plan, no payment card to start.