---
title: "What Commentware stores"
description: "What leaves your machine: what the server and the extension store, what they send, and what is deliberately not defended."
---

> Documentation Index
> Fetch the complete documentation index at: https://commentware.com/llms.txt
> Use this file to discover all available pages before exploring further.

# What Commentware stores

Commentware takes screenshots of web pages and keeps them, so it matters exactly
what is stored, where it is, and what moves. What the people who run the hub
hold is in the [Privacy Policy](/legal/privacy/), and the licenses are on the
[License](/legal/license/) page.

The server is yours. It runs on a machine you choose, and what it stores never
reaches the hub, so you decide what happens to it — and when you run a server
for other people, you answer to them for it.

## What is stored

All of it is on the machine running `commentware start` — the SQLite file and
the directory beside it.

| What                                                     | Why it is there                                                                                                              |
| -------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| Comments and mentions                                    | The product.                                                                                                                 |
| **Screenshots**                                          | Pixels of whatever page was on screen when a comment was placed.                                                             |
| Drawings                                                 | What somebody drew over a screenshot, kept as an image of its own.                                                           |
| Files attached to a comment                              | Whatever file somebody attached, of any type.                                                                                |
| **A page's title**                                       | How every list of pages names a page.                                                                                        |
| **Up to 128 characters of the commented element's text** | What tells an edited paragraph from a different one when a pin is re-found.                                                  |
| Access keys, **hashed**                                  | A key is the whole credential. Nothing can print one back.                                                                   |
| Tokens for agents that signed in through a browser       | An agent that authenticated in a browser gets a token of its own, and the key that signs those tokens is stored beside them. |

The two in bold are the ones you did not choose field by field, and they are the
reason the switch below exists.

When the element sits inside a component the page keeps hidden from other
scripts, the same kind of text is kept for the component around it as well, and
the switch below stops both.

When the element sits inside a page embedded in the page you comment on, by an
iframe or an `<object>` tag, and the embedded page is from the same site, the
same kind of text is kept for the element in it, and the switch stops it. When
the embedded page is from another site, the ways to find the element again (its
path, id and role) are kept, with the start of the embedded page's address
without any query, a fingerprint of the element's text and its length, and never
the first 128 characters of that text, whatever the switch says.

**It stays until you delete it.** [Uninstall Commentware](/docs/uninstall/) asks
whether to delete it, and keeps it unless you type `y`. A `y` deletes your
account's Commentware data directory, with the database, every screenshot,
drawing and attached file, and the logs in it, and the directory that holds the
server's own config file when that is a different one. A database your config
file keeps somewhere else is named and kept, and an export file you saved is
yours to delete.

A directory of screenshots, drawings and attached files that your config file
keeps somewhere else is named and kept too.

An export file an AI agent uploads to be imported is held beside the database,
in a directory named after it, such as `data.db.imports`, while the import
runs, and is deleted when the import ends, whatever the outcome. If the server
stops in the middle, the next `commentware start` deletes it. The directory
stays, so it goes with the data directory when you uninstall, and stays beside
a database your config file keeps somewhere else. Learn more about [importing
threads through an agent](/docs/using/export/#import-through-an-agent).

**A screenshot is the largest thing here.** A capture of a viewport can
contain a session token in a devtools panel, a customer record, an inbox — much
more of the page than the comment was about.

## Capture can be switched off

Screenshots can be switched off for one site or for the whole server. Off
refuses **new** captures and new drawings, and leaves stored ones readable. A
file attached to a comment is not a capture, so the switch has nothing to say
about it. The short piece of page text kept with an anchor goes with it, and a
page title does not. Learn more about [what is kept about the
page](/docs/concepts/threads-and-pins/#what-is-kept-about-the-page).

## What moves, and what does not

- **The server makes no outbound call that leaves your machine.** No telemetry,
  no update check, nothing. The one request it ever makes is to itself: when an
  agent authenticates in a browser, the gate reads the key that verifies its
  token from the server's own address. That dials the socket this process
  opened, and it only happens at all on a server whose address is loopback or
  HTTPS.
- **The extension makes one request of its own, to the package registry.**
  Once a day it asks the registry, at `https://registry.commentware.com`, which version of the
  extension is newest, so it can tell you when yours is behind. The [Privacy Policy](/legal/privacy/)
  says what that request carries and what the registry learns from it. That is
  separate from the first bullet: the server still makes no outbound call, and
  has no update check.
- **A screenshot, a drawing or an attached file leaves the server only to
  somebody holding a key.** The route that serves them, and the agent tools that
  read them, are behind the same access key or agent token as everything else;
  there is no unauthenticated read. What happens next is the key holder's: the
  extension shows it in your browser, an agent that reads one passes it to the
  model it runs on, and the options page's **Export / Import** screen, which is
  experimental, writes the screenshots, drawings and attached files of the
  threads you export into a file you choose. That file carries no key: anybody
  who has it can unzip it and open each screenshot, drawing and attached file. Nothing sends the file
  anywhere unless you import it, which uploads its screenshots, drawings and
  attached files to the server the extension is connected to. See [Export and
  import threads](/docs/using/export/).
- **Your browser only asks a server about a page on its own once that server
  has told it there are already comments on that site.** The icon's badge
  count and the side panel's list are both held to this; opening the comment
  overlay is different, because that is something you did, and it always
  asks, known site or not. The extension has permission to run on every page;
  nothing that asks on its own asks about one nobody has commented on yet.
- **The extension uses your clipboard only when you do.** It writes to it when
  you press a copy button — Chrome lists this as "Modify data you copy and
  paste" — and reads only what you paste into a comment. The website you are on
  cannot see the copy happen, so it cannot catch what is copied or swap it on
  the way. Like any website, it can still put something of its own on the
  clipboard shortly after you click anywhere on it, the copy button included.
- **One thing can leave, it is Chrome's, and you choose.** Dictated audio may be
  recognized by Google's speech servers, because that is what Chrome's speech
  API is. Nobody is defaulted into it, and "only on this computer" is enforced by
  Chrome rather than promised by Commentware. No audio ever reaches a
  Commentware server. See [where your voice is
  recognized](/docs/concepts/dictation/#where-your-voice-is-recognised). By
  default the microphone is open while an overlay is, and for five minutes
  after, so that the first word is heard; nothing is recognized or sent until
  you press the button. See
  [when the microphone is open](/docs/concepts/dictation/#when-the-microphone-is-open).

## What the installer keeps and asks for

The installer, `commentware-installer-cli`, is a program of its own, apart
from the server and the extension. It keeps your invite code in
`~/Commentware/invite` (`%USERPROFILE%\Commentware\invite` on Windows), with mode
`0600` on macOS and Linux. Deleting the file removes the code, and so does
[Uninstall Commentware](/docs/uninstall/). Learn more
about [the invite code](/docs/concepts/install/#the-invite-code).

On every run it asks two hosts. It asks the package registry, at
`https://registry.commentware.com`, for each part it installs or updates — the extension, the
server, or both, as [what a run installs and
updates](/docs/concepts/install/#what-a-run-installs-and-updates) describes. It
asks the hub for the list of invite-code digests for the batch your code names,
at `/codes/<batch>.json`. The address of that list holds the
first four characters of your code and nothing else about it.

The installer asks nodejs.org for a file only when it downloads Node.js:
when it sets up a server and finds no Node.js to run it on (it asks first when it
has a terminal to ask on), or when it moves its own copy of Node.js to a newer
version on an update. It sends nodejs.org no code and no key; nodejs.org sees the
address, the time, and a `User-Agent` naming the installer and its version. It
asks no other host.

## What is not defended

Stated plainly, because a security claim that is not true is worse than none.

- **Nothing is encrypted at rest.** The database is a file, every screenshot,
  drawing and attached file is a file, and the browser's copy of your access
  key is on disk. Anybody with your machine has all of it. This is a program you run on your own computer;
  defending it from its own operating system's owner would mean a passphrase on
  every command for a threat that already has the machine.
- **Plaintext over the network.** Bound to anything but loopback with no TLS in
  front, everything this server accepts crosses the network in the clear. The
  server warns you when you do it.
- **A `can_collaborate` key can write a lot.** It cannot delete, but it can
  resolve every thread on a server and comment in all of them. Everything it does
  is reversible, which is the property that makes the grant safe to hand out; it
  is not a quota.
- **A server sees every comment written to it.** That is what a server is for.
  If you connect to somebody else's, they can read what you write to it.
- **What is filtered about a page's address is its shape, never the page.** A
  small set of query parameters that look like a credential are withheld before
  the address is sent: when the extension asks what is on a page, and when you
  place a comment, move a page or import an export file. A parameter named
  `token`, `jwt` or `session`, a value shaped like a JWT, and every parameter
  on an OAuth or SSO callback path are withheld. Nothing here reads what is on
  the page to decide what is safe to send, and a URL shaped in a way this does
  not recognize still travels. A Chrome profile dedicated to the sites you comment
  on is the backstop for what a URL alone cannot show — see [a Chrome profile
  only for this](/docs/concepts/install/#a-chrome-profile-just-for-this).

## Commentware is for sites you are building

Your own domain, your own staging, your own localhost. On a page you do not
control, a hostile site has real reach: it can read what you type into the
composer, and it can hide or move the comment overlay entirely.

Some of that is defended and some of it is not, and the line is drawn where the
defense is cheap rather than where it is absolute. It is written down so it can
be disagreed with, and revisited the day people start commenting on pages they
do not control.

Two things it cannot do, which are the ones that would matter most: it cannot
reach your access key, and it cannot make Commentware act — every control that
ends in a write needs a real gesture from a real person, and a click a page
dispatched at one is refused.

## Comments are never treated as markup

A comment body is text a stranger wrote, drawn on somebody else's page. It is
parsed and drawn as elements, never turned into HTML, so no comment can contain
anything that runs. Links are clickable only for `http`, `https` and `mailto`;
anything else stays readable text.

## Next steps

- [Settings](/docs/server/settings/#screenshots): switch capture off for a site
  or for the whole server.