Threema vs Session vs No Trace Chat (2026): The No-Account Messenger Comparison
If you have ruled out Signal because of the phone number, the three serious account-free messengers in 2026 are Threema, Session, and No Trace Chat. Each solves “no phone number” differently — and the difference matters more than the cryptography.
Threema gives you a paid Swiss ID. Session gives you a free onion-routed identity. No Trace Chat skips identity entirely and uses room codes — there is no “you” on the network, only rooms.
This is the honest 3-way comparison. I include where each one breaks (because they all break somewhere), how they handle the things people forget to ask (metadata, jurisdiction, network effect), and the threat model each is actually built for.
I also touch on Threema vs Signal at the end, since that comparison drives a lot of the “should I switch?” question — but Signal is not account-free, so it sits separately.
The 30-second verdict
- Threema — buy once, Swiss, mature, the safest “default replacement for WhatsApp.” Best when you need a real identity that is not your phone.
- Session — free, onion-routed, the strongest metadata protection in the comparison. Best when who you talk to is what you want to hide, not just the message content.
- No Trace Chat — code-based, $4.99 lifetime, delete-on-read by default, no ID at all. Best for short-window or ephemeral conversations where there should be no record on either device after the chat is over.
If you only read one line: pick Threema for ongoing relationships, Session for first-contact and tip lines, No Trace Chat for one-off rooms.
Identity model — the most important difference
The three apps make three different choices about identity. This decides everything downstream.
Threema: a paid Swiss ID
When you install Threema, you generate a Threema ID — an 8-character string (e.g. ABCD1234). The ID is unique to your installation, ties to nothing about your real identity, and persists across conversations. You can optionally link a phone number or email as a verifiable handle — but it is not required.
This is persistent identity: same ID across all chats, same ID for years. If the server is subpoenaed for “messages between ABCD1234 and EFGH5678,” the server can confirm that the IDs talked at certain timestamps. The messages themselves are encrypted, but the relationship is visible.
Session: an anonymous routed ID
Session generates a 66-character Session ID derived from an Ed25519 keypair. Traffic is routed through a decentralized network of service nodes (the Lokinet), so the server you connect to does not know your IP or who you really are. The Session ID is persistent across reinstalls if you save the recovery phrase.
This is anonymous persistent identity: same ID across all chats, but the routing layer breaks the link between ID and IP. Even if a node is compromised, it sees one hop, not the whole conversation.
No Trace Chat: no identity, only rooms
No Trace Chat does not give you an ID. You pick a room code (e.g. ntchat, or any 6-32 char string). Anyone with the code joins; anyone without it cannot. The key for the room’s encryption is derived from the code through 100,000 rounds of PBKDF2.
This is ephemeral key-based access: there is no “you” on the network. The server sees encrypted blobs tied to a code-derived key, not to a user. Two different rooms with two different codes look like two different unrelated traffic streams.
The trade-off is obvious: there is no “Add Friend” button. You have to share the code through a side channel (in person, on Signal, on a sticky note). For one-off rooms, this is a feature. For “my whole contact graph migrates here,” it is friction.
Encryption — the second most important difference
| Item | Threema | Session | No Trace Chat |
|---|---|---|---|
| Protocol | NaCl (ECDH + XSalsa20-Poly1305) | Modified Signal Protocol | AES-256-GCM |
| Key derivation | Per-pair ECDH | Double Ratchet (modified) | PBKDF2 100,000 rounds from room code |
| Forward secrecy | Yes (per-message) | Reduced vs vanilla Signal | No (room key is static) |
| Post-compromise security | Yes | Reduced | No |
| Open source clients | Yes | Yes | No |
| Open source server | No | Yes (Lokinet) | No (Firestore-backed) |
| Independent audit | Yes (multiple) | Yes (Quarkslab 2023) | No |
Read the trade-offs carefully:
- Threema and Session both offer forward secrecy (a stolen key cannot decrypt past messages). No Trace Chat does not — the room code IS the key. If someone gets the code, they can decrypt the room from the start. This is fine for short-lived rooms (the use case) and bad for long-lived ones (do not use it as your year-round daily messenger).
- Session’s protocol fork drops some guarantees from vanilla Signal Protocol (specifically, deniability and the strongest post-compromise security). For most threat models, this is acceptable; for nation-state targets, it is a real concession.
- Threema is the most independently audited of the three. The cryptography has held up across multiple public reviews.
- No Trace Chat is not independently audited yet. The cryptography is straightforward (AES-256-GCM + PBKDF2 are textbook), but “textbook” does not equal “audited.” Use this disclosure as your weighting factor.
Metadata — the thing people forget to ask
End-to-end encryption protects message content. It does not protect who, when, how often, how big, from what IP. That is metadata, and it is what compromises sources, deanonymizes activists, and ends careers. Here is how the three handle it.
| Metadata leak | Threema | Session | No Trace Chat |
|---|---|---|---|
| Your IP visible to server | Yes (TLS) | No (Lokinet onion routing) | Yes (Firestore over HTTPS) |
| Who you talk to | Yes (encrypted graph on server) | No (no graph exists) | No (code-based, no user record) |
| When you talk | Yes | Reduced (routing delays) | Yes (Firestore timestamps) |
| Message size | Visible to server (encrypted blob) | Padded to fixed sizes | Visible (encrypted blob) |
| Contact graph leak risk | Low (server does not store contacts) | None | None |
| Push notification metadata | Yes (Apple/Google) | Optional | None — NTC has no push |
The interesting line is the last one. No Trace Chat does not send push notifications. Most messengers leak the recipient’s identity to Apple Push Notification Service or Google FCM with every message; even if the body is encrypted, the metadata “user X just got a message at 02:47” is logged. NTC opts out of push entirely. You check when you want to check.
Session’s onion routing is the strongest metadata protection here — at the cost of message delivery latency (5–30 seconds is common). If your threat model is “an adversary watching the IP layer,” Session is the right pick.
Jurisdiction — where the company can be subpoenaed
| App | Company | Jurisdiction | Subpoena risk |
|---|---|---|---|
| Threema | Threema GmbH | Switzerland | Low (Swiss DPA, no MLAT with US for civil) |
| Session | OPTF / Lokinet community | Australia (OPTF nonprofit) | Medium (Australia is 5-Eyes, but no central server holds messages) |
| No Trace Chat | Teamz Lab LTD | UK | Medium (UK is 5-Eyes; server sees encrypted blobs only; no plaintext to subpoena) |
For high-threat-model users, Switzerland > Australia > UK on jurisdiction alone. But “jurisdiction” only matters if the company has something to hand over. Session has no central server. No Trace Chat’s server holds AES-256-GCM ciphertext keyed to a room code the server never sees. Threema’s server holds encrypted message blobs for delivery.
Practical answer: if you assume any of the three will be subpoenaed and you cannot trust the cryptography, switch to Briar (peer-to-peer, no server). If you accept “encrypted blobs are safe,” all three are reasonable.
Disappearing messages — the headline NTC feature
| App | Default behavior | Timer options |
|---|---|---|
| Threema | Persist until deleted | Optional disappearing timer per chat |
| Session | Persist until deleted | Optional disappearing timer per conversation (1s–1wk) |
| No Trace Chat | Delete on read by default — no timer to set | None — the read event is the trigger |
This is the line where Threema and Session look the same and No Trace Chat looks different.
Threema and Session both offer optional, configurable disappearing messages. You enable the feature, pick a timer, and from that point on, new messages auto-delete. The catch: most users never enable it. A 2023 survey of Signal users (the same UX pattern) found under 25% had ever enabled disappearing messages on any chat.
No Trace Chat inverts the default. There is no “enable disappearing messages” toggle. Once the other person opens the chat and reads the message, it is marked deleted — gone from the chat, gone from the server. The only way to keep a message is to screenshot it (and NTC includes screenshot protection on iOS and warns on Android).
Which model wins:
- If you want opt-in ephemerality with full control (the chat should usually persist, but for specific conversations it should auto-delete): Threema or Session.
- If you want opt-out ephemerality (the chat should never persist by default, but you want a record sometimes — explicitly): No Trace Chat is the only one of the three that defaults to delete-on-read.
Network effect — where each one has users
| App | Active users (mid-2026 estimate) | User base concentration |
|---|---|---|
| Threema | ~12 million | DACH (Germany, Austria, Switzerland), security-aware EU |
| Session | ~3 million | Privacy enthusiasts, crypto-adjacent, journalists, activists |
| No Trace Chat | ~60 active devices (launched Feb 2026) | Early adopters, BD/IN/PK/SA/EG via Play Store |
Yes — No Trace Chat is tiny compared to Threema and Session. It launched in February 2026 with one-time pricing and zero ad spend. The 60 active devices is a real number from the Play Console. The 226 total installs include test devices.
So why mention it in the same comparison? Because for the use case it serves (one-off rooms, ephemeral exchanges, code-share-and-go), network size does not matter. You and the other person both install in 30 seconds. The room exists for the duration of the conversation. There is no “find me in your contacts” step.
If you are evaluating “what do I migrate my whole social graph to?” — Threema first, Session second, NTC not a candidate. If you are evaluating “what should I install for the next hard conversation I need to have?” — NTC is competitive.
Price and sustainability
| App | Price | Business model | Sustainability concern? |
|---|---|---|---|
| Threema | $4.99 one-time (consumer) | Sales + business tier | Low — profitable Swiss company since 2012 |
| Session | Free | Crypto-token-funded (SESH token), donations | Medium — token funding has wobbled |
| No Trace Chat | 50 free messages, then $4.99 lifetime | One-time purchase, no subscription | Medium — small studio, single-product revenue |
A note on Session’s funding: Session is partly funded by the Oxen / SESH token economy, which has been volatile. The OPTF foundation has stated commitment to keeping Session free, but if you build long-term workflows around it, build a fallback into your plan.
Threema is the only one of the three that is structurally sustainable. NTC’s $4.99 lifetime is honest pricing for a small studio but not a category-killer commitment.
Threema vs Signal — the bonus comparison
Most “Threema vs Session” searches actually come from people who tried Signal first, hit the phone-number wall, and want to know what to install instead. Here is the Signal-shaped answer.
| Feature | Signal | Threema |
|---|---|---|
| Phone number required | Yes | No |
| Email required | No | No |
| Encryption | Signal Protocol (gold standard) | NaCl (audited, strong) |
| Disappearing messages | Optional timer | Optional timer |
| Forward secrecy | Yes | Yes |
| Open source | Yes (client + server) | Yes (client only) |
| Jurisdiction | US | Switzerland |
| Price | Free | $4.99 one-time |
| Network effect | Massive (~70M MAU) | Small (~12M) |
| Backup model | Phone number recovery (the weak link) | Threema ID + manual backup |
The honest summary: Signal’s cryptography is better-audited. Threema’s identity model is safer. If the May 2026 phishing wave told us anything, it is that “better cryptography wrapped around a phishable identity” is not as safe as “decent cryptography wrapped around an unphishable identity.” Threema, Session, and No Trace Chat all bet on the identity side. Signal bets on the cryptography side.
For the average user, Signal is still fine. For the user who needs to assume a determined adversary, switch the bet.
Pick by use case
”I want a daily messenger to replace WhatsApp without my phone number”
Threema. Pay the $4.99. Migrate the relationships that matter. Use Signal for the people who refuse to switch.
”I am a journalist and a source wants to message me”
First contact: Signal (high recognition, gets sources to install something). Follow-up: Session for the metadata protection, or No Trace Chat for a single-window tip exchange where delete-on-read removes the burden of remembering to set a timer.
”I run an HR team and we need a private internal channel for sensitive conversations”
No Trace Chat. Code-based rooms mean you do not exchange phone numbers with employees. Delete-on-read means the conversation does not live in any export. The low UX bar means a non-technical employee can join in 30 seconds.
”I am building a tool for whistleblowers”
Use SecureDrop for first contact (it is the standard). Use Session for ongoing back-and-forth. Do not use No Trace Chat alone for whistleblower comms — the centralized server is a single point of subpoena even if it sees only ciphertext. Combine layers.
”My partner and I want a private chat the kids can’t read”
No Trace Chat. You both install in 30 seconds, type a room code, done. Delete-on-read means if either phone gets handed off, there is nothing in the chat.
”I am paranoid and want the most metadata-protected option”
Session (or Briar if the threat model is country-level). Accept the latency. The onion routing earns the wait.
Common questions
Is Session really anonymous if Australia is a 5-Eyes country?
Session’s anonymity does not come from Australian law. It comes from the architecture — no central server holds messages, the Lokinet routes traffic through community-run nodes, and the company (OPTF) has nothing to hand over even if compelled. Australian jurisdiction is a risk factor for the org, not for the messaging.
Is Threema actually open source?
The client apps are open source (you can audit what runs on your phone). The server is not. Threema argues — and most cryptographers agree — that the cryptography is auditable end-to-end, so the closed server is acceptable. If your threat model rejects all closed-source components, Session and Element are better fits.
Does No Trace Chat scale to group chats?
Yes — group chats and a “Topics” mode where each participant gets a separate isolated conversation with the room creator (useful for anonymous feedback). But the scaling story is not the same as a Discord or Telegram replacement — the architecture is built for small private rooms, not 100-person communities.
Which one is cheapest to get started with?
All three have effectively zero start cost: Session is free, Threema is $4.99, No Trace Chat is free for 50 messages then $4.99 lifetime. The cost to commit is highest for Threema (you pay upfront), but you pay once forever.
What about WhatsApp’s “Incognito Chat” or Telegram’s “Secret Chats”?
WhatsApp Incognito Chat (launched 13 May 2026) is for chats with Meta AI, not human-to-human. Regular WhatsApp messages remain E2E. Telegram Secret Chats are E2E but device-bound and require manual enablement per chat. Neither is in the same category as Threema/Session/NTC — both require phone numbers.
Why is “No Trace Chat” not as well known as Threema or Session?
Because it launched in February 2026 and we have done zero paid marketing. The Play Console shows 226 installs, ~60 active devices, and 1 paid customer at $4.99. We are a UK indie studio (Teamz Lab LTD, no. 16106867) shipping privacy-first apps. If “small, indie, audited?-not yet” disqualifies an option for your threat model, pick Threema. If “small, indie, code-based ephemeral” matches your need, give NTC a 30-second try.
Building this category yourself
If you are a founder, engineering lead, or product team thinking about building a privacy-first messenger or a custom encrypted channel for your business, here is the honest economics:
- An MVP encrypted messenger (E2E, no account, basic chat): $40,000–$80,000, 3–5 months
- A code-based room model like NTC (room code + PBKDF2 + Firestore + delete-on-read): $25,000–$50,000, 2–3 months
- A custom whistleblower channel (single-purpose, integrated into an existing website): $10,000–$25,000, 4–8 weeks
All Teamz Lab engagements run through Upwork escrow: you fund the milestone, we ship the milestone, you release the payment after you verify the result.
- Agency: Teamz Lab on Upwork
- Portfolio: /portfolio/
- Direct: teamzlab.com
We are a UK-registered company (Teamz Lab LTD, Companies House 16106867, Manchester M40 8WN).
The bottom line
The “right” no-account messenger depends on what you are protecting.
- Identity = phone number is the risk → Threema (paid Swiss ID), Session (anonymous ID), No Trace Chat (no ID, room codes).
- Metadata leak is the risk → Session (onion routing) > No Trace Chat (no push, no profile) > Threema.
- Persistence is the risk (you do not want a record) → No Trace Chat (default delete-on-read) > Session + Threema with timer enabled.
- Auditability is the requirement → Threema (most audits) > Session (one major audit) > No Trace Chat (none yet).
- Sustainability of the company is a requirement → Threema (profitable since 2012) > Session (token-funded) > No Trace Chat (indie, single product).
Most serious users I work with run two of the three: Threema for daily relationships, Session for sensitive contacts, and No Trace Chat for short-window code-based rooms when a fresh disposable channel is the point.
Try No Trace Chat: /no-trace-chat/ — 50 free messages, $4.99 lifetime after, no phone, no email, no signup. Code-based rooms with delete-on-read by default.
Related reading:
Have a project in mind?