# Security and privacy

- URL: https://getroomi.com/docs/security
- Built: 2026-10-26

Roomi runs code written by other people, and holds records that are
not mock data even though every demo is: who was shown a pitch, what they did
and what they wrote back, and plans for businesses that have not launched. This
page says how your code is kept apart from everything else, what the platform
holds about you and your viewers, and who can see it.

## Where it runs

Roomi runs in four places: the app at `app.getroomi.com`, the API
at `api.getroomi.com`, the rooms and demos on `getroomi.app`, and
the connector at `mcp.getroomi.com`. Roomi keeps a written
security gate for what it runs; its lines are:

- authentication in front of every route, checked by requesting each one
  signed out;
- one workspace refused another's projects, links, analytics, feedback and
  files by id, checked by attacking it;
- no address answering that nobody chose, and no preview addresses;
- viewer links unguessable, expiring, revocable, and checked on every request;
- publishers' containers out of reach of every platform binding and secret, and
  demos on their own domain;
- secrets in the host's secret store, none in a committed file;
- storage private, confirmed from an unauthenticated client;
- a dependency audit clean of critical and high findings;
- passkeys confirmed in production, from a real device;
- a written threat model.

The rest of this page describes the system as it is built.

## Your code

### Its own container

A [container demo](https://getroomi.com/docs/containers) runs only in a container of its own,
never inside the platform. The platform does not run your image: it runs one
runner image of its own, Node 24 and a small supervisor, and hands it your
build, the `/app` folder your Dockerfile produced. A container only ever runs
one build, refuses a second, and stops when the build does. Your code runs as
the `node` user, not root, and owns `/app` and nothing else.

Each private link gets its own container, so one viewer's clicks never reach
another's copy. The platform never unpacks a container bundle itself: it checks
that the upload is a gzipped archive and stores it, and only the runner, inside
the container, unpacks it.

### No secrets, bindings or network

A demo's container is started with two port numbers and nothing else:

- **no platform binding**: no database, no storage, no route back into the
  platform;
- **no secret** of the platform's in its environment, only the `ENV` your own
  image declared;
- **no internet**: the bundle is streamed in over a control port, so the demo
  never needs to fetch anything, and cannot.

The viewer's own pass into the demo is taken out of every request before it
reaches your server, so your code never sees it.

### Static demos

A [static demo](https://getroomi.com/docs/static) is files: HTML, CSS, JavaScript and images. The
platform unpacks the archive into private storage and serves the files as they
are. None of it runs on the platform; it runs in the viewer's browser, on the
demo's own origin.

### A separate domain

Rooms and demos live on `getroomi.app`, a different registrable domain
from `getroomi.com`, where the app, the API and sign-in are. Every
project gets two origins there:

- `<project>.getroomi.app` is the room: the stage, the tour, the notes,
  comments and next steps.
- `<project>--demo.getroomi.app` is your demo, framed by the room.

Two reasons. A demo's script can set cookies for its parent domain, so on a
shared domain one could plant a session where people sign in. And one
phishing page deployed by a stranger would otherwise get the product's own
domain flagged. On `getroomi.app` itself, the room's session cookie is
for its own host alone, and the room refuses any write that does not come from
the room's own page.

The room's pages run only the room's own script and styles, talk only to the
room, frame only their own demo, and are framed by nobody. The demo may be
framed by its own room and by its own pages (a showcase framing its other apps),
and nothing else; a `frame-ancestors` or
`X-Frame-Options` of your own is replaced by that rule, and the rest of your
content security policy is kept.

### Pages

A page in the room's Read more rail is rendered sandboxed: an HTML page runs no
script, loads nothing from the network, and has no origin of its own. See
[Pages](https://getroomi.com/docs/pages).

## Secrets never leave your machine

`roomi deploy` scans for secrets with [gitleaks](https://github.com/gitleaks/gitleaks)
before anything is uploaded, and again on what it built:

1. **The project folder**, leaving out installed dependencies (`node_modules`),
   git's own store, and the folders build tools generate (`.next`, `.turbo`
   and the like, where Next writes keys of its own). Whatever of them would
   ship is scanned in the next step.
2. **The build**: a static demo's output folder, or a container demo's bundle
   together with the `ENV` it will start with, since a secret baked into an
   image's environment would ship in its manifest.

A finding stops the deploy, and nothing is uploaded. The report names the rule
and the file and line, with the value redacted, and asks you to remove the
secret and rotate it, since it has been on disk in plain text. Your own
`.gitleaksignore` is not read, so a finding cannot be waved through from inside
the project. A scanner that could not run is a failed scan, not a clean one:
the deploy stops there too.

While it rehearses, `roomi` talks only to the copy of your build it started on
this machine's loopback address. Nothing leaves the machine until `roomi
deploy --commit`, which uploads exactly what was rehearsed.

## Mock data only

Every viewer gets a copy of your demo, so nothing in it may be real: no customer
data, no production keys, no connection to a real system. A demo's container
has no internet, so it could not reach one anyway. The room tells every viewer
so: "This demo runs on mock data. Nothing you do here reaches a real system."

## What the platform holds

### About you and your workspace

- Your account: your name, email and avatar as GitHub or Google gave them.
  Sign-in sessions record the address and browser they were made from, as the
  sign-in library does. For a passkey, only its public half is kept.
- Your workspace's members, projects, builds, pages, brand, community card and
  cover, next-step settings, and your notes and follow-ups on viewers.
- Your builds' archives and bundles, in private storage.

### About your viewers

- The name you gave each private link, and the email if you gave one.
- The people who opened each link: the person it was made for, and anyone it
  was forwarded to who said who they are, with the name and email they typed.
  None is verified, unless the room asks for a verified email and they prove
  it with a code ([How people get in](https://getroomi.com/docs/immersive#how-people-get-in)).
  Roomi emails a viewer their own link only when you ask it to
  ([Having it sent for you](https://getroomi.com/docs/sharing#having-it-sent-for-you)), and a code
  only when the room asks them to prove their email.
- Their visits: the time spent on each app and page, and the moments of each
  visit, with a device class (phone, tablet or desktop). No IP address, browser
  version or location. See [Analytics and the
  pipeline](https://getroomi.com/docs/analytics#what-is-not-collected).
- With their yes, what they did inside the demo: the screens they opened, in
  order and for how long, and what they clicked or used there, by the demo's
  own labels. Never what they typed, and nothing
  from a password, card or one-time-code field. Each viewer's is kept for 12
  months, then only as totals that name nobody; it is the most detailed thing
  the platform holds about a viewer. See [Screens and
  clicks](https://getroomi.com/docs/screens#what-is-logged).
- Each viewer's answer about their clicks: yes, no or stopped, the version of
  the words they were shown, and when.
- What they wrote and chose: comments, where they were pinned, the replies,
  next-step answers and reactions.
- At a public address: an anonymous visitor id, stored hashed and used only to
  count people.

### About community members

Someone who signs in to comment or react at a listed project's public address
is known to the room, and to you, by their public face alone: the name their
sign-in gave them, their handle if they chose one, and their avatar. Their
email never reaches the room or the publisher.

### Files are served by their row

Logos, covers, pages and build files are stored privately. They are read by
the platform from the database row they belong to, in your workspace, and
streamed; no storage address or key ever reaches a browser.

## Who can see it

- **Your workspace's members** see everything the workspace holds. See [Teams
  and invites](https://getroomi.com/docs/teams).
- **A viewer** sees the room their link opens, and your replies to their own
  comments. Never anyone else's.
- **Anyone** sees only what you chose to make public and that passed Roomi's checks: a
  listed project's card, cover and public address, and your public page's
  name, avatar, handle, bio and listings. Never an email.
- **Roomi** sees what running the service needs: workspaces, their
  members' emails, projects, plans, listings and the checks run on them, and
  reports.
  Every action it takes on your workspace carries a reason and is recorded.

## Workspace isolation

Every request the API answers is scoped to the workspace you are working in,
in one data-access layer that every query goes through. Asking for another
workspace's project, link, visit, comment, note or file by its id is answered
"not found", the same as an id that does not exist, so a refusal says nothing
about what exists. The rooms get a narrower door still: find a project by its
address, check a link, and record what that link's viewer does.

## Viewer links

- A link's token is 128 random bits. The room finds a link by a hash of it.
  Beside the hash the token is kept encrypted (AES-256-GCM) with a key that
  lives only in the platform's secret store, never in its database, so a
  member can be shown the address again. Someone who read the database alone
  could open no room. Each time an address is shown again it is recorded in the
  project's history, and a connection that may only read is never shown one.
- When a viewer opens it, the room swaps the token for a session cookie of its
  own, for the room's host alone, and takes the token out of the address bar.
  The room sends no referrer.
- Every request is checked against the link again, not only the first. A
  revoked or expired link, a paused project, or a link that is not on the plan
  any more gets the same plain "Not found" as a wrong token.
- The pass that joins a phone to the same copy ("Open on your phone") lasts ten
  minutes. The one-time passes the app makes for "Preview as viewer" and for a
  community sign-in work once, within two minutes, on their own project's
  address only.

Every project starts unlisted: without a link, a preview pass, or an approved
community card, its room answers nobody.

## Signing in

### The app

Sign in with GitHub or Google; the same button signs you up. Once signed in,
you can add a passkey in **Settings** and sign in with it after that.

### roomi

`roomi login` prints a code and a page to open; you confirm the code in the
app, where you are signed in, and only `roomi` can ask for such a code. The
token goes in the macOS Keychain on a Mac, and elsewhere in a file only you can
read; `roomi logout` ends the session on the server too.

For a script or CI, make an API token in Settings. It is shown once, and only
its hash is kept. It acts as you in one workspace and reaches only what `roomi`
does: never billing, your account, the team, or other tokens. Revoke it in Settings and it stops at once; it also stops
when it expires and when you leave that workspace. `roomi` reads it from
`ROOMI_TOKEN` and never stores it. See [Install the CLI](https://getroomi.com/docs/install).

`roomi logs` shows what a demo's server prints, and the platform replaces
anything that looks like a password, key or token with `[redacted]` before
it leaves. Still, a demo should never print a real secret: demos run on mock
data.

## Claude acts as you

The connector signs in by OAuth through Roomi. When Claude connects,
the app shows what it may do, and you allow or deny it:

| Permission | Lets Claude |
|---|---|
| `pitch:read` | See your projects, their builds, viewer links, visits and feedback |
| `pitch:write` | Deploy demos, create and revoke viewer links, and add pages to rooms |
| `offline_access` | Stay connected until you disconnect it |

A token is issued for the connector alone, for the workspace you were in when
you allowed it, and every call is checked again: a connection allowed to read
cannot change anything, and one whose person has left the workspace is
refused. Claude never holds a cloud credential or your `roomi` token. Each tool
that changes something says so, and Claude asks you before using it. The
consent page warns you when the app asking is not Claude. See [Deploying from
Claude](https://getroomi.com/docs/claude).

## Deleting a project

Deleting a project, in its **Settings** tab, takes it out of your workspace and
stops its links at once. Its address is held for 30 days so a link already sent
cannot open someone else's project. The project is marked deleted rather than
erased: its records stay in the database.
The one exception is what viewers did inside the demo: a deleted project's
screens and clicks, totals included, are erased within 30 days.

> [!NOTE]
> Every workspace starts on Free, and moves to Pro or Team whenever you like, in Settings, Billing. Sign in at app.getroomi.com with GitHub or Google, then add the connector to Claude at https://mcp.getroomi.com/mcp, or run the CLI with npx @getroomi/cli. These pages describe the connector, the CLI, pitch.json, the app and the room as they are.
