Everything OpenEmail does,
and how it does it.

Every address on the domain receives, including ones that have never been created. One switch closes it.

Point several domains at one inbox, subdomains included.

A starter p=none record, printed to copy or written by a sync, never tightened for you.

An address that works for a fortnight and then stops, so a signup cannot follow you.

Catch-all already gives you a throwaway address for every signup, but it lives as long as the domain does.

Reply from the exact address the mail arrived on.

Read every address in one stream, or narrow to the two or three you actually work out of.

Point any address, or everything a domain accepts, at an outside mailbox instead of this one.

Put your own mark and logo in the sidebar, in place of ours.

Forgiving words and operators like from: and has:, inside the folder you are reading.

Ask the command palette for what you want and it writes the query.

A message you cannot read, turned into a language you can, without leaving it.

Name a label, pick one of six colours, and filter the list down to it.

Keep a private note attached to a thread.

What your mailbox is actually doing, drawn rather than guessed at.

The people you already write to, offered as you type.

The palette is ⌘K, the assistant is ⌘0, and the list moves under the arrow keys.

A body written once, versioned, and sent many times: from the composer, from your own code, or by an agent.

Every attachment this mailbox holds, in one place you can search, download and clear out.

Your account sets the defaults. A workspace can answer differently, and any address can have its own signature and tracking.

One sign-off for every address, and a different one for any address that needs it.

Formatting, inline completion and emoji shortcodes in the composer.

Write in your own language and have it arrive in the recipient’s.

A calendar at /mail/calendar in month, week and day views, holding both your meetings and the mail you have queued to go out later.

Autosaved three seconds after you stop typing, and reopened from the Drafts folder with the recipients, the subject and the body intact. The attachments and the From address stay behind.

Write it now, land it when they are awake.

A window to change your mind, and the composer comes back exactly as it was.

Whether a message you sent has been opened, when, how many times and which of its links were followed. On unless you turn it off, and plain about the readings it cannot get.

Tracked links and the open pixel on a subdomain you choose, such as links.yourdomain.com, instead of the OpenEmail address.

Download links for the files you send on a subdomain you choose, such as files.yourdomain.com, instead of the OpenEmail address.

Pick them with the paperclip or paste them in. A pasted image lands in the body rather than the file list, and a file dragged onto the composer is not attached at all. On an OpenEmail mailbox incoming files sit in object storage, one object each, and opening a thread pulls every one of them.

A chat that can act, not just answer. On every plan, Free included.

Write the body, and the subject writes itself.

Give it the gist and get the whole body back, in the first person as you.

Drafts are shaped by how you actually write.

Read and rewrite the system prompts OpenEmail uses.

Triage, labelling, summaries and first-pass replies, done before you open the tab.

Summaries are the one piece that runs on arrival today; triage, labelling and first-pass replies do not.

A mark beside the sender when the sending domain’s published records line up.

A real picture for everyone you correspond with when one can be found, and a mark seeded on their identity when it cannot.

Mail the sending domain itself disowns lands in Spam rather than the inbox.

Who is this, in fifty words, and is the domain a look-alike?

A label on the message when the words look generated rather than written.

One address, or everything from a domain, stopped before it reaches you.

Mail carrying the words you do not want to read does not open in front of you.

Your own conditions, and what should happen to anything that matches them.

Point Claude, or any MCP client, at your mailbox.

Self-service client registration with PKCE, so an app can ask for access properly.

Consent and revocation are here; scope is not, so a token reaches your whole mailbox rather than the part an app asked for.

A documented HTTP API with issuable, scopable, revocable keys.

A TypeScript client first, then the rest.

Tell your endpoint when mail arrives, instead of making you poll.

Hand billing@ to the person who does the billing.

One address means one address.

A role says what somebody may do; an address grant says what they may do it to.

Share with someone who has not signed up yet and have them invited.

The invisible image that tells a sender you opened their mail is gone before you see the message.

Stop a sender fetching anything from their own server while you read.

Per-category switches in Account → Notifications, and the ones that matter are honestly marked as unswitchable.

Full message bodies and attachment bytes on R2, indexed per mailbox.

Arrive with the mail you already have, whether an archive exported from wherever it lives now or the account itself, threaded as it was and filed where it belongs.

There is no importer of any kind yet; the one part already solved is threading, because imported mail that keeps its original headers threads itself alongside mail that arrives later.

One download with everything in it: every message and attachment in a format another mail app can open, plus your contacts, labels, rules, templates and calendar.

Nothing exports today: the only things that leave through the product are one attachment at a time and your own encryption key, and what an archive can carry is a rebuild rather than the original bytes.

Mail moves over TLS on the hops we run, and transport alone never turns the padlock green, because nothing on this backend can read the transport off a delivery.

Every field of a message sealed before it is written down (body, subject, addresses and attachment bytes), so a copy of the database is ciphertext rather than mail.

Only the credentials you hand us are sealed this way today; bodies, subjects and attachments are stored as they arrived, and the envelope that will seal them is built but deliberately wired to nothing.

OpenPGP keys made in your browser. Mail you send to another OpenEmail address can be sealed before it leaves the tab, and sealed mail addressed to you opens in the reading pane, decrypted on your machine. The keys are never ours to hand over.