Skip to content
Sign inRequest access

Security & privacy overview

uMarker is designed to be safe to deploy on a client’s real site. That constraint shapes the whole architecture: the capture surface runs inside arbitrary third-party pages, and the dashboard holds many tenants’ data in one database. Exactly one of the project’s twelve founding principles is marked non-negotiable — security and privacy — and it names its trust boundaries by hand: input validation, tenant and workspace isolation, PII masking at capture, hashed or encrypted secrets. The rule that follows is blunt: access decisions fail closed. A project with no listed domain serves the widget nowhere, and an account whose plan key names nothing resolves to the smallest tier rather than the largest.

This page is the map. Each capability below has a dedicated page with the exact mechanism, and the last section lists the things a reviewer will ask about that uMarker does not have.

Tenant isolation

Every tenant-owned record carries an account_id. Most are filtered automatically by a global Eloquent scope that resolves the current account from the authenticated principal; the two auth principals and the billing, audit, sent-mail, support-message and coupon-redemption tables are filtered by an explicit predicate at each call site instead. Either way, cross-tenant access is answered 404, never with another tenant’s rows. See Tenancy & data model.

Fail-closed authorization

The client’s view of “am I allowed here” is advisory. Every ingest and dashboard request is re-validated server-side and denied by default. See Roles & access.

In-browser redaction

Masking runs in the page, before the screenshot is taken, never as a server-side cleanup. Secret-looking query-string values are blanked on every project; masking the values people type and the regions you mark is a per-project switch that ships off. See PII redaction.

Retention that actually runs

Setting a retention window for reports is an Agency-and-above capability; on those plans a nightly job deletes reports past it, media included, and on every other plan no report is deleted by age. A second job clears stored media older than the plan’s media window — 30 days on Free, 730 on Agency, unlimited on an Enterprise term — while keeping the report. See Data processing.

Export and erasure

A full JSON export of everything the account owns (never a secret), and a hard delete that reaches the rows and the stored files. Both are buttons, not support requests.

SSRF-safe outbound

Tenant-supplied webhook and channel URLs must be public HTTPS; hosts that resolve to private, loopback, link-local or reserved IP ranges are refused. See Channels.

Escape-first rich text

Author-written announcement and changelog bodies are HTML-escaped first, then a tiny markdown allowlist is applied: no raw HTML, script or style can survive.

Visible support access

When our support staff sign in as one of your members, it is recorded and shown to you, in your own account settings, with the time and the window it lasted.

An account is the data-isolation boundary. Most tenant-owned models use a BelongsToAccount trait that adds a global scope filtering every query by the current account_id, and auto-fills account_id on create. The current account is resolved from the authenticated principal: a dashboard user, or a widget/extension identity on the token guard, both of which carry account_id. The two auth principals and the billing, audit, sent-mail, support-message and coupon-redemption tables carry account_id without the trait, and are filtered by an explicit predicate wherever they are read. In console and queue contexts there is no request user, so nothing is auto-scoped and callers must set the account explicitly.

Inside an account, two further layers narrow reach: workspaces (a request scoped to one workspace via the X-Workspace-Id header sees only that workspace’s rows) and per-project access, where a member reaches exactly the projects they are attached to. Full detail in Tenancy & data model.

The extension and the snippet decide whether to show themselves on the client, but that decision is never trusted for data. There is one config endpoint per surface, and each re-evaluates visibility from scratch on every call. The snippet’s resolves the public key to a project, confirms that project is published on the snippet surface and its account is not suspended, and checks the page’s origin against the project’s allowed domains — it carries no caller identity, so that domain list is what stops a leaked public key from serving the widget somewhere else. The extension’s resolves the page’s own host to a project inside the signed-in tester’s account, confirms the project is published on the extension surface, and confirms that tester is authorized for it. Either way, anything else returns hidden. The ingest endpoint independently re-resolves the project and re-checks the origin before storing a report. Revoking an extension identity flags it and deletes its active tokens on the spot, so cached client authorization can’t keep the widget alive.

Where it happens carries no condition: every masking and text-redaction step that runs at all runs in the reporter’s own browser, before the screenshot is rendered and before the payload is posted. There is no server-side cleanup pass, so whatever is not masked on the device reaches us exactly as captured.

How much is masked depends on one per-project switch, and a new project ships with it off:

  • On every project, always. Query-string values whose name suggests a secret (token, session, sig, email, phone and friends, including accessToken-style camelCase) are blanked the moment a URL is recorded, so the raw value is never even held in memory.
  • Only with Auto-redact sensitive fields on (Project → Widget → Setup → Privacy): the values typed into form fields and anything matching a CSS selector you list as always-sensitive are masked before the screenshot is rendered, and secret-shaped strings in console lines, breadcrumbs and request URLs (captured only in Technical mode) are replaced with [redacted] as the payload is assembled. Until you turn it on, the screenshot carries whatever the visitor had typed.

The browser extension runs the same widget engine as the snippet, so it reads the same switch and applies the same masking and text redaction. Console, network and breadcrumb text exists only on a project set to Technical capture; on a Normal project nothing technical is recorded, and the server discards it if it arrives anyway. Detail, including the honest limits, in PII redaction.

SSRF-safe outbound and escape-first rich text

Section titled “SSRF-safe outbound and escape-first rich text”

Two helpers guard the places where tenant-supplied content becomes an outbound request or rendered markup:

  • Outbound URLs (notification channels, webhooks, a Jira base URL) are validated at write time: the URL must be https, and its host must resolve only to public IP addresses. Private (RFC 1918), loopback, link-local (including the cloud-metadata address 169.254.169.254) and reserved ranges are refused, decimal and octal spellings included, and delivery jobs additionally disable redirect-following.
  • Rich bodies (announcements, changelog entries) are rendered through an escape-first markdown subset: the input is HTML-escaped first, so no author-supplied HTML, <script>, style or event handler can survive, and only a fixed set of markers (paragraphs, lists, bold, italic, code, and http/https links decorated with rel="noopener nofollow") is turned into tags.

REST API keys are stored only as a SHA-256 hash with a short non-secret prefix; the plaintext (md_live_…) is shown once at creation and never stored, so a database read never yields a usable key. Tracker credentials and channel secrets are encrypted at rest and hidden from serialization — including the channel URL, which for Slack and Teams is the credential, and Telegram’s bot token, stored with its chat (and topic) — write-only once saved, like the rest. One column is the exception and is worth naming: a tracker’s inbound webhook token is the lookup key of its status-back URL, so it is hidden from serialization but stored in plaintext. Provider error text is scrubbed before it is stored: on the tracker paths — the queued one and the manual button alike — URLs and credential-shaped strings are stripped, and channel delivery strips the webhook URL out of the failure it records. The exception branch of the Test connection button is the one path that stores a provider message unscrubbed.

Access tokens are pruned when they go idle (90 days by default, configurable) rather than on an absolute clock, so a session someone uses daily is never cut off and a laptop nobody has opened since last season stops being a key. Changing a password ends every other session.

Security-relevant events are written to audit_logs through a single Audit helper that records the action, the acting user or extension identity, the subject, any operator wearing that identity, and a timestamp. Rows fall into two classes, and the difference matters before you rely on one:

  • Compliance — support sign-ins, member suspension, account and report deletion, plan and entitlement changes, role and invitation changes, and issuing or revoking an extension identity. These are written whatever the platform settings say, are exempt from the write ceiling, and are kept for a year by default.
  • Activity — sign-ins, REST key issuance and revocation, widget key rotation, status and assignment changes, and ordinary content edits. An operator can switch this class off, a write burst can shed it (the gap itself is recorded), and a nightly prune deletes it after 30 days by default.

Whatever the table holds at the time is included in your data export.

A reviewer’s time is better spent on the gaps than on the list above, so here they are:

No signed DPA

There is no data-processing agreement to countersign yet, and no contractual subprocessor list. The roles are clear (you are the controller, uMarker is the processor), but the paper is not written. See Data processing.

No certification

No SOC 2, no ISO 27001, no published penetration-test letter. The technical controls on this page are real and tested; none of them has been audited by a third party.

No announced hosting region

The deployment region is an operator setting and has not been decided and published. Do not read in-Kingdom or EU residency into this documentation; neither is promised.

AI is off until your account turns it on

Nothing from your account reaches a model unless your plan includes AI and an account admin switches consent on. Then report text only — never screenshots — goes to a provider in our chain (Groq or Google Gemini). See Subprocessors.

Found a security issue? Write to security@umarker.com (or support@umarker.com if you hear nothing back) with the URL, the steps to reproduce and the impact. We acknowledge within 5 business days, and ask you not to publish details until it is fixed or 90 days have passed, whichever comes first. We will not pursue legal action against good-faith research that uses your own account and stops at the first access to someone else’s data. The full policy is on the security page, and both addresses are published in security.txt.