A plain-language guide to every privacy decision the app makes — and what each choice means for you.
Tag is built on one principle: your messages belong to you and the people you send them to — nobody else. No company reads them. No algorithm ranks them. No server stores them beyond what's needed for delivery.
To back that up, the app was designed so that even the servers it relies on are structurally incapable of reading your messages — not just prohibited from doing so by a privacy policy.
Tag has no sign-up. No email address. No phone number. No username you carry between groups.
Every time you join a group, the app generates a fresh, random identity just for that group — a new ID, a new cryptographic key pair, a new display name if you choose. Someone watching network traffic sees that identity interacting with that group. They cannot link it to your other groups, your device, or your real identity.
Every message is encrypted on your device before it leaves. It arrives at the recipient's device still encrypted and is decrypted there. Nothing in between — not the servers, not the network — can read it.
The encryption key lives in the join link. When you share that link with someone, you're handing them the key to read the conversation. The group's privacy is only as strong as how securely you share the link.
When a recipient is offline, the sender deposits a message blob with the relay server. That blob is encrypted twice: once with the shared group key, and again with the recipient's personal public key.
The result: the relay server holds ciphertext it cannot open at either layer.
Every message carries a cryptographic hash. When you receive it, your device verifies the hash before displaying the message. A tampered message is flagged — it cannot be silently altered in transit.
All connections between the app and Tag servers use HTTPS and WSS (WebSocket Secure). This means traffic is TLS-encrypted at the transport layer as well as end-to-end encrypted at the application layer. An observer on the network sees only ciphertext — they cannot read even the metadata that the server itself is allowed to see.
The app blocks cleartext HTTP entirely. If a server URL is accidentally configured without HTTPS, the connection will fail rather than silently send data over an unencrypted channel.
When your app first connects to a server, it records that server's public key. Future connections verify the key matches. If it changes unexpectedly, the app warns you before proceeding — giving you meaningful protection against connection interception without breaking legitimate server migrations.
You can run your own relay and signaling servers. The TOFU model applies to any server you configure, including self-hosted ones with custom certificates. Your app learns to trust your server on first use and warns you if anything unexpected changes.
Tag uses two servers — a signaling server and a relay server — kept deliberately separate so neither holds the full picture.
| Information | Signaling server | Relay server |
|---|---|---|
| Message content | Never | Never |
| Your real name or identity | Never | Never |
| Which group you're in | Never | |
| Who else is online with you | Never | |
| When you're active | ||
| That two IDs are the same person | Cannot determine | Cannot determine |
| Blob count in your mailbox | Never |
When you and the people you're messaging are all online at the same time, Tag connects your devices directly — no server involved in message delivery at all. This is the default and preferred path.
The signaling server only facilitates the initial handshake (exchanging connection details). Once the connection is established, the signaling server steps out entirely. Your messages flow directly between devices.
Mitigation: use a VPN. A VPN masks your real public IP — the address visible to STUN servers, your peer, and any server you communicate with becomes the VPN exit node's IP instead of your own. If IP privacy matters to you, use a VPN before opening the app.
If a direct connection isn't possible due to network conditions, messages fall back through a TURN relay server. The TURN server routes the encrypted packets between devices — it cannot read message content, but it does see traffic volume, timing, and the endpoints (IP addresses) of both devices. This is a degraded but acceptable fallback; direct P2P is always attempted first.
Tag is transparent about the trade-offs each choice involves. Here's what each decision means for your privacy.
If Keep History was enabled: history entries for that group are marked "group left" but not deleted — the audit trail remains intact. To remove them, use Purge History in Settings.
Tag's security claims are designed to be verifiable by a third party without trusting the app. The optional Communication History feature makes this possible.
When enabled, the app keeps a log of everything it sends or receives across the device boundary — recorded exactly as it crossed: outbound data is logged after encryption, inbound data is logged before decryption. The log never contains readable message text. If it did, the app would have failed its own security claim.
Note that peer IP exposure happens at connection time regardless of whether history is enabled — P2P connections inherently exchange IP addresses. History simply creates a durable record of it. Using a VPN replaces your real IP with the VPN exit node's IP in all of these contexts.
To eliminate this exposure from the history record: disable Keep History and use Purge History in Settings. Once purged, the record no longer exists on your device.
Every message entry's content is opaque ciphertext — the device sent and received nothing readable.
The set of event types matches the app's stated communication paths — no hidden channels appear.
Timestamps, remote parties, and event counts match what the app claims to have communicated.
Message content — ciphertext requiring a group key the auditor does not hold.
Your display name, group names, or colors — not exposed to auditors; these exist for your own export only.
Your encryption keys, signing keys, or any credential — never written to the audit database.
No email, phone number, or username. Nothing ties your groups together or links you to a profile that can be subpoenaed, breached, or sold.
Messages are encrypted before they leave your device. There is nothing to scan — not on the way in, not on the way out, not at rest on any server.
The app contains no analytics SDK, no crash reporter that phones home, no ad framework. Your usage patterns are not observed.
Tag does not use Google Firebase, Apple Push Notifications, AWS, or any large-platform operator in production. Every server that touches your data must be under your control — or the control of someone you've chosen to trust.