mountable.io

Permissions and keys

Sign-in, organisation roles and invitations, management keys, API keys and S3 keys, whole-filesystem grants, and ending access.

Accounts and sign-in

Use an email link or Google from the sign-in page. The same verified email address reaches the same account through either method. Google sign-in accepts Gmail and verified Workspace addresses; use the email link for another address that Google cannot authoritatively verify.

Email links are single-use and expire after fifteen minutes. Complete the confirmation on the link page. Opening it in another browser asks you to type the sign-in address; entering the wrong address consumes that link. Request a new link if it is expired, used or no longer valid. A mail scanner merely opening the URL does not complete sign-in.

One account may belong to several organisations. The console's organisation selector changes which one you manage; check it before changing access or billing. Creating an organisation makes you its owner. An account with no organisation can create one or accept an invitation.

Signing out and CLI approval

Sign out ends this browser's login and mounts created through it. Sign out everywhere ends all your browser and CLI logins, across organisations, and the mounts made through them. Keys are separate: revoke a key explicitly if you want to end its access. If the console reports that sign-out failed, you are still signed in; retry the action rather than assuming it completed.

Sign-out blocks login renewal and writes immediately. A previously copied access token can still authorise reads until its expiry, at most fifteen minutes; this is separate from the mount-revocation bound below.

mountable login prints a device link and a code valid for ten minutes. Approve only a code matching your own terminal. Wait for Signed in in the terminal: signing out of the approving browser before exchange cancels the unused approval. A CLI login lasts up to thirty days, with short-lived access tokens renewed automatically; sign in again after expiry or revocation.

Grants cover whole filesystems

A grant gives a member, a group, or an API key access to one whole filesystem, read-only (ro) or read-write (rw). rw implies ro. To separate what different people or agents can see, give them different filesystems: there are no per-directory grants.

Roles

RoleCan
ownereverything an admin can, plus managing owners and deleting the organisation
adminmanage filesystems, grants, members, groups, and every kind of key; mount every filesystem read-write
membermount what they or their groups are granted

Owners alone can promote/demote owners or remove them, and the last owner cannot leave or be demoted. Promote another member to owner first if you want to leave. Owners/admins manage groups and their membership; an account must already be an organisation member to be added to one of its groups.

Organisation members can see its members, groups and filesystem metadata, including usage. Grants control mounting and file contents, not the secrecy of filesystem names within the organisation. Owners/admins can inspect grants and list every live mount session. Ordinary members cannot list mount sessions, but may revoke a known session they created. A key lists/revokes only its own sessions.

Removing a member also removes their group memberships in that organisation and ends that person's browser/CLI logins and login-based mounts, including logins used for other organisations. Their other memberships are not deleted; they can sign in again to use the organisations they still belong to.

Invitations

An owner/admin creates an invitation for an email address as member or admin. Copy its one-time link and share it with that person. It is valid for seven days and can be accepted only while signed in with that address; a forwarded link does not grant access to a different account.

If the console says it is for another account, sign out and sign in with the invited address. For an expired, cancelled or already-used link, ask an owner/admin for a new invitation. Accepting a link for an organisation you already belong to keeps your existing role. An owner can promote a member to owner after they join; owner is not an invitation role. For an ordinary member, an owner/admin then grants filesystem access directly or through a group before they can mount it.

Keys

Software uses keys instead of a login. There are three kinds, each for one job:

KeyLooks likeForCreated by
Management keymtblm_…a provisioning service: creating and deleting filesystems, keys and grantsan owner or admin, on Management keys
API keymtbl_…a backend that works with files: mount tickets, the files API, webhooksan owner or admin on API keys, or a management key
S3 keyaccess key ID MTBL… and a secretan S3 client on a trusted backend, for one filesysteman owner or admin on the filesystem's page, or a management key

Management keys manage; API keys access files. Management keys and API keys are sent the same way (Authorization: Bearer …, or MOUNTABLE_API_KEY for the CLI and SDKs), and the prefix decides what is allowed. A call with the wrong kind answers 403 with code management_key_required or api_key_required. Keys never manage members, groups, invitations, management keys, billing or the organisation: those answer 403 api_key_forbidden. GET /api/v1/me shows a key's organisation as api_key: {id, org_id} or management_key: {id, org_id}.

Every key's secret is shown once, when it is created, and cannot be recovered from the list; save it in your secret manager. A key lasts thirty days by default, from one to 365 days. For a lost or expired key, create a replacement and update the software that uses it, then revoke the old one. Lists show a key's name, prefix or access key ID, and lifetime, never the secret. Keys are long-lived credentials: keep them on a trusted backend and never put one in a sandbox. Give a sandbox a mount ticket instead.

Management keys

Only an owner or admin creates a management key, and it works only while its creator is an owner or admin of the organisation. It may:

  • create filesystems, and delete them at once;
  • set the limits of any filesystem, and read the usage of every filesystem in the organisation;
  • create and revoke API keys and S3 keys, and change grants.

It never reads or writes files: it cannot create mount tickets or sessions, use the files API or S3, or manage webhooks (403 api_key_required). The API and S3 keys it creates never outlive it, and stop working when it is revoked or expires.

Give one management key to the service that creates a filesystem per customer or per project, and let it hand each backend an API key or S3 key for its own filesystem.

API keys

An API key belongs to one organisation and never holds more than its creator. A key may:

  • list, read and see the usage of the filesystems it has a grant on;
  • create mount sessions up to its grant, and list or revoke the sessions it created;
  • manage the webhooks of a filesystem it has a read-write grant on.

Creating filesystems and setting their limits take a management key; an API key that tries gets 403 management_key_required.

A key can be limited to one filesystem when it is created: choose the filesystem and its mode (read-only or read-write) on the API keys page, or send filesystem_id and mode (default rw) to POST /api/v1/orgs/{org_id}/api-keys. The key gets that grant at once and can never reach another filesystem: granting it another filesystem answers 409 key_limited_to_filesystem, and it lists only its own filesystem. Key views show the limit as filesystem_id. Give such a key to a backend that needs exactly one filesystem.

Deleting filesystems, changing grants, and creating or revoking API keys answer an API key with 403 management_key_required.

S3 keys

An S3 key is an access key ID and secret for exactly one filesystem, read-only or read-write. Any S3 client uses it with the filesystem ID as the bucket; see S3 API. Create one on the filesystem's page, or with a management key:

printf 'header = "Authorization: Bearer %s"\n' "$MOUNTABLE_MANAGEMENT_KEY" |
  curl -q --silent --show-error --fail-with-body --config - \
    --request POST "https://mountable.io/api/v1/orgs/$ORG_ID/filesystems/$FS_ID/s3-keys" \
    --header "Content-Type: application/json" \
    --data '{"name": "duckdb", "mode": "ro", "expires_in_days": 90}'
# → {"access_key_id": "MTBL…", "secret_access_key": "…", "filesystem_id": …, "mode": "ro", "expires_at": …}

GET on the same path lists the filesystem's S3 keys, and DELETE …/s3-keys/{access_key_id} revokes one. A revoked or expired S3 key, or one whose creator lost its authority (a person who is no longer an owner or admin, or a management key that was revoked or expired), is refused within 15 seconds. Deleting the filesystem revokes its S3 keys.

Mode is chosen per session

Each mount session picks ro or rw, up to the grant. You can mount read-write on your Linux laptop while an agent's sandbox mounts the same filesystem read-only.

For people, the strongest direct or group grant wins. For example, a direct ro grant plus a group's rw grant allows rw. Removing the group grant then leaves ro: an existing rw session is revoked and a new ro session can be created. A key's own grant is additionally capped by what its creator currently holds, so demoting/removing the creator can reduce the key's access.

Filesystem creation and deletion

Owners/admins and management keys create filesystems; an API key cannot (403 management_key_required). A management key gets no grant on what it creates: grant an API key the access its worker needs. Names need not be unique: use the opaque filesystem ID in commands. The configured payment-method requirement and quotas still apply. If creation times out with an unknown outcome, refresh the list before creating again: the first request may already have succeeded.

An owner/admin deletes a filesystem in the console; a management key sends DELETE /api/v1/orgs/{org_id}/filesystems/{fs_id}. Deletion is immediate: the files are removed at once, and its mount sessions, webhooks and S3 keys end. An owner deletes an organisation in the console, which also deletes its active filesystems. Storage/file-count billing includes the deletion day. This does not itself promise physical erasure of stored content: follow the Privacy Policy and contact support for erasure or retrieval requests. Earlier charges remain payable.

What revokes sessions

Every change that reduces privileges revokes the affected sessions and unused tickets at once: deleting or downgrading a grant, removing someone from a group that carried the grant, removing a member, revoking or expiring an API key (or the management key that created it), and deleting the filesystem. No new operation is admitted more than 15 seconds later; the client creates a new session under the new authority.

File modes are presentation

POSIX owners and mode bits inside a mount are shown for tools that expect them. They are not an access-control boundary; grants are.