Threat Model
We design against three adversary classes:
- The Curious Manager β wants to know who said something. Has access to Teams/Zoom admin, email logs, corporate network monitoring. Motivation: performance management, retaliation.
- The IT/Legal Team β operates under legal pressure. Has access to eDiscovery tools, Microsoft 365 compliance center, corporate email servers, potentially a subpoena. Motivation: compliance, litigation hold.
- The Abuser β a participant using anonymity to harass, threaten, or probe moderation. Motivation: harm to others or circumventing content policy.
Against the first two, the protection is architectural: nothing we hold, and nothing we post into your organization's systems, says who the sender is. It has two limits we state plainly. The message text itself does reach Teams β the organizer reads every message in their private chat with the bot, and shared messages are posted to the meeting chat β so it sits in your organization's chat history and eDiscovery like any other message, without a sender. And a sender's own work laptop, managed phone or office network can record that they visited notonrecord.com, and when; for the strongest protection, senders should use a personal phone on mobile data. We mitigate the third by moderation and rate limiting β without breaking anonymity for the first two.
Data Retention Matrix
Every datum we touch, what happens to it, and when it's gone. TTL=0 means it never reaches storage.
| Data element | Collected? | Stored? | TTL | Notes |
|---|---|---|---|---|
| Sender phone number (SMS) | Yes β Twilio delivers it | Never stored raw | TTL=0 | Immediately HMAC-SHA256 hashed for routing lookup only. Raw number discarded. |
| Sender IP address (web form) | Yes β used for rate limiting | Never stored | TTL=0 | Rate limit check passes through IP; IP never written to session, log, or relay payload. |
| Message content (web, SMS) | Yes | Never stored | TTL=0 | Moderated β relayed to meeting chat β not retained. Only a message count integer is stored per session. |
| Meeting session metadata | Yes | In-memory only | Session lifetime + 30s | Stored in Node.js process RAM only. Session ends when meeting ends. Process restart wipes all sessions. |
| Teams conversation ID | Yes | In-memory only | Session lifetime | Required to post to Teams chat. Cleared when session ends. |
| Phone number (HMAC hash, routing) | Derived | In-memory only | Session lifetime | Used to route inbound SMS to the correct session. Cannot be reversed to recover the phone number. |
| Voice call recipient (email/phone) | Yes β user provides | Yes, disk (encrypted) | Until sent (scheduled: up to 7 days) | Held AES-256-GCM encrypted with the message and, for a card payment, the order's Stripe payment reference while the order waits for its random delay or its scheduled time, so a restart cannot lose a paid order and the payment can be refunded if it cannot be delivered, then erased. After that only an HMAC hash is kept, in memory, for the per-recipient limits. |
| Reply threads (email sent through /send) | Yes β when the order is paid | Yes, disk (encrypted) | 7 days | The first 140 characters of the message, a masked recipient address (jo***@example.com) and any replies, AES-256-GCM encrypted, deleted after 7 days. No sender identity. |
| AI call transcript and summary | Yes β every AI call | Yes, disk (encrypted) | 7 days (90 with a kept occasion recording) | What was said on the call, its summary and the recipient name the sender typed, AES-256-GCM encrypted; the buyer reads them through their private report link. No sender identity. |
| AI call recording | Yes β every AI call | Yes, disk (encrypted) | 24 hours; bought: 7 days (occasion keepsake: 90) | Recorded by Twilio; Twilio's copy is deleted once ours is stored. No sender identity. |
| Scheduled messages and calls | Yes β if you pick a later time | Yes, disk (encrypted) | Until sent (up to 7 days; occasions 60) | The message, the recipient, the time and, for a card payment, the Stripe payment reference (so it can be refunded if it is cancelled or cannot be delivered), AES-256-GCM encrypted, deleted once sent, cancelled or refunded (see Β§5). |
| Abuse report content (Report button in a Teams meeting) | Yes β if report submitted | Yes, disk | 30 days | The reported message text with its session ID and channel, stored as a file and deleted after 30 days. A copy is emailed to our support inbox. No sender identity. |
| Support requests | Yes β if you send one | Yes, disk | 90 days | What you typed into the support form, including a report about a message you received, and an email address only if you chose to give one for a reply. Deleted after 90 days. A copy is emailed to our support inbox (up to 100 a day; past that, requests are only filed). |
| Stripe payment data | Yes | At Stripe, not us | Per Stripe policy | We receive only a payment intent ID. Card data never touches our servers. Stripe's privacy policy applies. |
| Waitlist email | Yes β if user submits | Yes, disk | Until user requests deletion | Voluntarily provided. Not linked to any session or message. Can be deleted on request: [email protected] |
| Moderation API payloads | Yes β message text sent to OpenAI | Not by us | Per OpenAI policy | Only message text is sent. No session ID, sender identity, or metadata is included in the moderation API call. |
Identity Stripping
SMS path
Twilio delivers an inbound SMS webhook to our server. The payload includes the sender's phone number. Our processing order:
- Receive webhook from Twilio
- Compute HMAC-SHA256 of the normalized phone number (E.164 format)
- Use hash to look up active session (routing only)
- Discard raw phone number from memory
- Extract message text only
- Moderate content (text only β no phone, no hash sent to OpenAI)
- Relay "π¬ Anonymous: [message]" to Teams/Zoom chat
- Increment session message counter (integer only)
At no point is the phone number stored, logged, or included in the relay payload. The HMAC hash is stored in-memory only for session routing and is not logged.
Web form path
User submits message via browser form. Processing order:
- Receive HTTP POST
- Rate limit check using IP address (express-rate-limit, in-memory only)
- IP address goes no further β not stored, not logged, not included in session
- Extract message text
- Moderate content
- Relay to Teams/Zoom chat
Voice call path
User provides recipient phone/email and message text. Processing order:
- Pre-moderation check (before payment)
- HMAC-hash recipient for cooldown check β the check keeps only the hash
- Stripe payment intent created (we store payment intent ID only)
- On payment confirm: TTS generates audio, Twilio places call
- Recipient identifier, held encrypted until the call is placed (a scheduled call: until its time), discarded; only the cooldown hash is retained, in memory
Keyed Hashing (HMAC-SHA256)
We use HMAC-SHA256 rather than raw SHA-256 wherever we hash identifying information (phone numbers, email addresses).
Implementation
// Normalize first to prevent bypass via formatting variation
const normalized = phone.replace(/\D/g, '').replace(/^1?/, '+1').slice(0, 12);
// HMAC-SHA256 with server secret
const hash = crypto
.createHmac('sha256', process.env.HMAC_SECRET)
.update(normalized)
.digest('hex');
Normalization
We normalize identifiers before hashing to prevent bypass via formatting variation:
- Phone numbers: Stripped to digits, normalized to E.164 (
+1XXXXXXXXXX) - Email addresses: Lowercased, then reduced to the mailbox they deliver to: the
+tag is dropped and, for Gmail, so are the dots (googlemail.comcounts asgmail.com). The per-recipient limits count[email protected]and[email protected]as one inbox, and an opt-out is stored under the address as typed and under its mailbox, so it blocks every spelling. Older opt-outs, made before addresses were matched this way, hold only the address as typed and block only that spelling.
Secret rotation
The HMAC secret is set via environment variable (HMAC_SECRET). Rotation is supported but resets in-memory cooldown continuity β existing sessions are unaffected since sessions are scoped to meeting lifetime. A process restart after rotation is sufficient.
Provider Metadata and Linkage
This is the most important architectural section for enterprise reviewers. The risk: NotOnRecord touches multiple providers (Cloudflare, Twilio, Teams/Zoom, Stripe, OpenAI, ElevenLabs, our email provider). Could a determined adversary join records across providers to identify a sender?
The joinable graph β what each provider sees
| Provider | What they hold | What they do NOT hold |
|---|---|---|
| Cloudflare | Sees every request in readable form, because TLS ends there: visitor IP, URL, and form contents such as message text and the recipient's number or email; keeps its own request logs | Card details (payment happens on Stripe's own pages) |
| Twilio | To/From numbers, Call SID, timestamps; carries the call audio, and so the spoken message; holds a recording until we have stored our copy and deleted Twilio's; for texts into a meeting, the sender's phone number and the text | Session ID, payer identity |
| Teams / Zoom | The organizer's review card with the text of every message (discarded ones included), shared messages posted as "Anonymous: [message]", the session link, conversation ID, timestamps | Sender identity, sender phone number |
| Stripe | Card/payer identity, payment intent, payer IP, timestamp, amount | Message content, recipient identity, session ID |
| OpenAI | Message text, moderation timestamp; for AI calls, the live call audio (including the recipient's voice), the transcript and the summary; text for standard voices, the “Rephrase” option and the support assistant | Sender identity, session ID, phone, IP, payment data |
| ElevenLabs | Message text turned into speech (voice messages sent through /send, the voicemail an AI call leaves); for a plain AI call it carries when our main route cannot place it: the message, the recipient's name and background the sender typed, the number called, the live call audio, and its own record of that conversation (audio and transcript), kept under its retention settings | Sender identity, session ID, IP, payment data |
| Email provider | Recipient address and the email itself (the message text), timestamps; its own mail logs | Sender identity, session ID |
| NotOnRecord | Session ID, message count (integer), HMAC phone hash (in-memory, session-scoped); message content and recipients only for the windows listed in Β§2 and Β§8, with a card-paid order's Stripe payment reference until it is delivered | Sender phone (raw), sender IP, message content beyond those windows, payer identity |
Join path classification
We formally enumerate three categories of linkage risk:
- β Architecturally impossible β the data required for the join does not exist in any system we control or any provider we use
- β οΈ Subpoena-dependent + probabilistic β requires coordinated legal action against multiple providers, and even then yields probabilistic inference rather than deterministic identity
- πΆ User-opt-in β user explicitly chose a path that creates linkage; documented in UX; cannot be subpoenaed away because the user made the choice
| Join attempt | Meeting/SMS | Meeting/Web | Voice | |
|---|---|---|---|---|
| IP β content | β | β οΈ Subpoena+TS | β οΈ Subpoena+prob | β οΈ Subpoena+prob |
| Phone β content | β οΈ Subpoena+TS | N/A | N/A | N/A |
| Payer β recipient | N/A | N/A | β οΈ Subpoena+prob* | β οΈ Subpoena+prob* |
| Payer β recording | N/A | N/A | β οΈ Subpoena | N/A |
| Email β identity | N/A | N/A | πΆ Opt-in | N/A |
| Content β identity | β | β | β* | β* |
* Until a call or email paid by card is delivered (usually a few minutes; one booked for later waits until its time, up to 7 days), our encrypted record of the order keeps its Stripe payment reference with it, so legal orders to us and to Stripe together would link the payer to that order's recipient and message exactly. Once the order is delivered, cancelled or refunded, that record is deleted (encrypted backups made while it waited keep it until they are destroyed, at most 180 days later) and the entries above apply.
Temporal obfuscation: the Bayesian model
For paid channels, the primary residual linkage vector is timestamp correlation: an adversary with both a Stripe record (payer at time Tβ) and a Twilio or SMTP record (dispatch at time Tβ) could attempt to infer P(same person | Tβ β Tβ = Ξ).
We address this with a non-uniform randomized delay between payment confirmation and dispatch. The delay distribution is heavy-tailed:
P(Ξ β 10β60s) β 60% // most calls
P(Ξ β 60β180s) β 25%
P(Ξ β 3β8 min) β 10%
P(Ξ β 8β20 min) β 5% // long tail β high anonymity window
Which channels apply this delay: anonymous voice calls, and anonymous email paid by card, ordered on the website (an email paid with a credit goes out at once, and sends through the private-beta API go out right away). AI agent calls do not. That product places a live two-way conversation the buyer may choose to listen to in real time, so an unannounced delay of up to twenty minutes would break the product rather than protect it. Agent-call buyers should assume the Stripe timestamp and the Twilio timestamp are close together, and treat that as the weaker privacy position it is. Every other property described on this page applies to agent calls unchanged.
Why heavy-tailed rather than uniform? A uniform distribution over [5s, 120s] is statistically fingerprintable β an attacker with enough observations can model it and narrow the correlation window. A mixture distribution with long tails has higher entropy H(Ξ), which directly reduces the posterior confidence of timestamp-based linkage.
Formally: if Stripe events arrive as a Poisson process with rate Ξ»β and Twilio events with rate Ξ»β, and the introduced delay follows distribution D, then the posterior probability that a specific Stripe event caused a specific Twilio event is:
P(match | Stripe=Tβ, Twilio=Tβ) β P(Ξ = TββTβ) Β· P(Tβ from Ξ»β) Β· P(Tβ from Ξ»β)
As H(D) increases:
β More candidate Stripe events fall within the plausible delay window
β Posterior P(match) drops from β1.0 toward 1/N where N = candidate set size
β At scale (high Ξ»), N grows β anonymity increases with volume
The goal is not zero correlation β it is plausible deniability under realistic adversary models. An adversary cannot determine with certainty which Stripe payment corresponds to which call. They can only make probabilistic inferences under conditions that require multi-party legal coordination.
Additional mitigations
- Meeting chat has no payment linkage β SMS and web form messages involve no Stripe events. Twilio and Teams are temporally separated by 50β500ms jitter. No payment join vector exists.
- No shared session identifier across providers β Session IDs are never sent to Twilio, Stripe, or OpenAI. The one exception is the meeting link itself: it contains the session ID, so Teams holds it, and Cloudflare sees it in the address of every visit to that link.
- Nginx access_log suppressed on all anonymous-path endpoints β No IP-to-action log exists at our reverse proxy. The "IP never stored" claim holds on our own servers; Cloudflare, which carries all traffic to the site, keeps its own logs (see Β§10).
- Scheduled messages are held encrypted until their send time β If you schedule a message, call, or email for later (up to 7 days, or up to 60 days for an occasion call booked in advance), it is stored AES-256-GCM encrypted on disk (same key model as recordings), delivered at the time you chose, then cleared. An anonymous scheduled message carries no name, email address or IP address, but if it was paid by card it carries its Stripe payment reference until it is sent (as a card-paid immediate send does for its few minutes), so it can be refunded if it is cancelled or cannot be delivered: during that longer hold, our record and Stripe's together link the payment to the message. Occasion calls (Santa, birthday, congratulations) are the exception, because they are the attributed product: that encrypted booking does carry the buyer's email, the sender name the character reads out and its Stripe payment reference. It is held until the call is placed and then deleted; the buyer's email is kept only until the last email about that call has been sent.
- Recordings are encrypted at rest with a short lifetime β Call audio is stored AES-256-GCM encrypted on disk so a paying customer can retrieve it from their report, and so the "buy the recording after reading the transcript" option can exist. Purchased recordings are kept 7 days (90 days for an occasion-call keepsake, which is the product the buyer paid for); audio nobody buys is deleted within 24 hours. The encryption key is a local file readable only by the service account, and the audio carries no sender identity.
Content Moderation & Degraded Mode
We moderate message content to prevent harassment, threats, and abuse. Moderation operates on message text only β no sender identity is included in moderation API calls.
Moderation state machine
β (3 consecutive API failures)
DEGRADED
β (3 consecutive API successes AND >60s since last failure)
NORMAL
The dual recovery condition (successes + time) prevents oscillation on intermittent outages where the API alternates between passing and failing.
Degraded mode policy
| Channel | Degraded mode behavior | Rationale |
|---|---|---|
| SMS | Blocked entirely | High velocity harassment vector; no substitute filter sufficient |
| Voice | Blocked entirely | High impact per-message; audio harassment cannot be easily keyword-filtered |
| Web form | Basic keyword filter + existing rate limits | Lower velocity; rate limiting provides secondary mitigation |
| Basic keyword filter + existing rate limits | Lower velocity; per-recipient cooldown provides secondary mitigation |
Anti-probe rate limiting
The moderation API is a content oracle β attackers could probe it to learn what content is blocked and craft circumventions. Mitigation: identical message content submitted more than 3 times within 5 seconds is rejected without calling the moderation API. The rejection is indistinguishable from a moderation failure.
Moderation before payment
For paid channels (voice, email), content is moderated before Stripe payment intent creation. This eliminates paid-abuse scenarios (where an attacker pays to send prohibited content) and reduces chargeback exposure.
Health endpoint
Moderation system state is exposed at GET /health for operational monitoring:
{
"moderation": {
"available": true,
"degraded": false,
"failStreak": 0, // consecutive failures (0 = healthy)
"successStreak": 14, // consecutive successes since last recovery
"lastFailureTs": null,
"lastSuccessTs": "2026-03-01T09:00:00Z",
"degradedSince": null
}
}
Abuse Handling Policy
Per-recipient limits
Messages bought through /send are limited to 3 per recipient in any 7 days, whoever sends them. Every page also keeps a minimum gap per recipient: one voice call to a number every 10 minutes (/voice and /send), one AI call to a number every 15 minutes (/agent) and one email to an address every 5 minutes (/email and /send). Every limit is keyed on an HMAC hash of the recipient's number or address β we track targets, not senders. The counters are held in memory, so a server restart resets them.
Abuse reporting and opt-out
Recipients have two always-available controls, linked from delivered messages:
- Report abuse: [email protected] β see notonrecord.com/support. Every report is investigated and we can block the sending path.
- Opt-out: notonrecord.com/unsubscribe. The number or address is blocked from receiving anything through NotOnRecord again β enforced at checkout, so a sender cannot even pay to reach it.
The opt-out list stores only a keyed HMAC of the contact: enough to block delivery, never a usable contact list, and not reversible into one. Opt-outs do not expire; we lift one only when the person who uses that number or address asks us to.
Session-scoped reporting additionally uses single-use signed tokens rather than raw session IDs, which prevents:
- Spam reports by parties who never received the message
- Session enumeration via brute-forced report attempts
What triggers action
| Event | Automated action | What's logged |
|---|---|---|
| Moderation API blocks content | Message rejected; sender sees generic error | Session ID + blocked category (no message content, no sender) |
| Rate limit exceeded | Request rejected with 429 | Nothing (rate limit handled in-memory by express-rate-limit) |
| Abuse report submitted | Report filed; support notified by email | The reported message text, session ID and channel (kept 30 days; a copy goes to the support inbox) |
| Multiple independent reports within 1 hour | Session auto-throttled (future) | Session ID + report count |
Retention of abuse artifacts
An abuse report is stored as a file on our server with the reported message text, its session ID and channel, and is deleted after 30 days; a copy is emailed to our support inbox so a person can act on it. Requests sent through our support form, including reports about a message someone received, are kept the same way for 90 days, with an email address only if the sender chose to give one. The application log records only that a report was filed, never the message. No sender identity is present in any report β by design, we don't have it.
Subpoena Resistance
If we receive a subpoena for records identifying who sent a specific anonymous message:
- We do not have a sender phone number or IP address β it was never stored
- We do not have the content of a meeting message β it was relayed and not retained β unless someone reported it as abuse (kept 30 days, see Β§7). Elsewhere we keep content only for a short, fixed time: an email's reply thread and an anonymous AI call's transcript (7 days), a paid message or call until it is sent (one booked for later: up to 7 days), and anything someone types into our support form, such as a report quoting a message they received (90 days). None of it carries a sender's name, phone number or IP address, and only a support request keeps an email address (the one its writer chose to give); a card-paid order waiting to be sent carries its Stripe payment reference, which Stripe can match to the payer.
- We have a session ID, session timestamps, and a message count integer
- We have an HMAC hash of a phone number, keyed on a server secret we hold β this is of limited use without also having the source phone number to verify against
What a subpoena to us produces: a meeting happened, N anonymous messages were sent, the meeting started and ended at these times. Nothing linking any individual to any message.
Provider subpoena considerations
A subpoena to Twilio would reveal that a specific phone number sent a text to our Twilio number at a specific time. Twilio also carries the text itself to us, and keeps its own message logs under its own policy. A sophisticated adversary combining a Twilio subpoena with meeting participant lists narrows the field to meeting attendees who had their phone nearby. This is the residual privacy risk that we document honestly: we cannot protect against a scenario where an adversary has both provider subpoena responses and meeting attendance records.
A subpoena to Cloudflare, which carries every web request (see Β§10), could show which IP addresses opened a meeting link or submitted a form, and when. Matched against the time a message appeared or was delivered, that narrows the field in the same way, which is why the IP-to-content joins in Β§5 are marked subpoena-dependent rather than impossible.
For maximum protection, participants can use the web form from a non-corporate device or network β in that case, even Twilio is not in the picture.
Failure Modes
| Failure | Behavior | Privacy impact |
|---|---|---|
| Node process crash / restart | All sessions wiped; active meetings lose bot | None β wipe is the privacy-preserving outcome |
| OpenAI moderation API unavailable | Degraded mode (see Β§6) | None β no identity data sent either way |
| Twilio webhook delivery failure | Message not relayed; sender sees no error (Twilio retries) | None |
| Teams Bot Framework token expiry | Relay fails; session error logged | None β message content not persisted on failure |
| HMAC secret compromise | An attacker with secret can brute-force phone hashes in-memory | Medium β rotate secret + restart; active sessions affected until restart |
| Rate limit store cleared (restart) | Rate limit counters reset; brief window of slightly higher permitted velocity | None β no identity data involved |
Operational Realities
This section documents constraints we cannot architect away β they are properties of operating on top of third-party infrastructure. We document them because enterprise reviewers deserve an honest picture, not a curated one.
Stripe as the strongest identity anchor
Stripe retains: card fingerprint, billing email, payer IP at checkout, payment timestamp, and amount. This is true regardless of anything we do. Stripe's privacy policy governs this data β not ours.
What we control: Stripe metadata fields (which we leave empty of message content and recipient identity), and our timing delay (which reduces timestamp correlation confidence). What we cannot control: Stripe's own data retention. Enterprise reviewers should treat Stripe's privacy policy as the binding constraint for paid-channel identity risk on the payer side.
Practical implication: A person who pays for a voice call is not anonymous to Stripe. They are anonymous to the recipient, to us, and to anyone without a Stripe subpoena. If maximum anonymity is required, use the meeting chat web form β it involves no payment processing.
Traffic volume and anonymity
Counterintuitively, the system's privacy properties improve with scale.
At low transaction volume, timestamp-based correlation is easier: few Stripe and Twilio events exist within any given time window, so the candidate set is small and inference confidence is higher. As transaction volume increases, more events fall within the plausible delay window for any given payment β the candidate set N grows, and P(correct match) approaches 1/N.
This is a structural property of the temporal obfuscation model: anonymity scales with usage. It does not degrade with scale, as is common in other systems.
Edge layer: Cloudflare
The site is served through Cloudflare, and Cloudflare terminates TLS. Every request therefore passes through Cloudflare in readable form: the visitor's IP address, the URL, and the contents of any form submitted, including message text and the recipient's number or email address. Cloudflare processes that traffic, and keeps its own logs of it, under its own privacy policy, which we do not control. Its security features (firewall rules and bot checks) can also record blocked or challenged requests.
Our own servers do not log IP addresses on the anonymous submission paths: our nginx reverse proxy suppresses access logs on those endpoints (access_log off), and the application does not write them.
Node.js diagnostic artifacts
Node.js can generate heap dumps (--heapdump) and diagnostic reports that could, in theory, capture in-memory recording buffers or session data. In production:
- Heap dumps are not enabled β no
--heapdumpflag, nov8.writeHeapSnapshot()call - Node diagnostic reports are disabled (
--no-reportis not explicitly set, but no report triggers are configured) - No APM agent (Datadog, New Relic, etc.) is installed β these can capture request/response bodies for large payloads
If we add APM or profiling tooling in the future, we will configure body capture exclusions on anonymous-path routes before deployment.
Future infrastructure: number pool rotation
As visibility increases, enterprise IT teams may begin blocking our Twilio numbers or flagging our domain. To maintain service continuity and resist targeted blocking:
- We plan to operate a pool of Twilio numbers, rotated per meeting session
- We plan to use multiple sending domains for email delivery
- Domain rotation infrastructure is not yet built β planned for post-launch after first blocking events are observed
Number pool rotation also slightly improves anonymity: a subpoena to Twilio against a specific phone number yields a smaller candidate set if many numbers are in use simultaneously.
What "anonymous" means in this context
We use "anonymous" to mean: sender identity is not present in any system record we hold or control, and cannot be recovered without multi-party legal action against third-party providers followed by probabilistic inference.
We do not claim: cryptographic unlinkability, protection against all possible adversaries, or anonymity in the presence of physical surveillance, device compromise, or behavioral analysis outside our system.
The threat model we are solving is: corporate IT teams, meeting organizers, and legal/compliance teams operating within normal organizational authority. We are not designed to withstand nation-state adversaries or coordinated law enforcement with full provider cooperation.
Audit & Contact
We intend to commission an independent security audit before general availability. We will publish the results (including findings) on this page.
If you've identified a security issue or privacy concern:
- Security: [email protected]
- Privacy: [email protected]
- Delete your waitlist data: [email protected] with subject "Delete my data"
We will respond to security reports within 48 hours.