Mailbox Protocols Compared: IMAP vs POP3 vs JMAP vs Exchange (2026)
A side-by-side matrix of the four mailbox access protocols — sync model, offline behaviour, push, multi-device, server load. Plus which one you should actually be running in 2026.
A side-by-side matrix of the four mailbox access protocols — sync model, offline behaviour, push, multi-device, server load. Plus which one you should actually be running in 2026.
Picture this: you add your work account to a new phone and the inbox comes back with four messages in it. Four. The account has years of mail behind it.
Nothing was hacked. The desktop client has been running POP3 since the day someone set it up, downloading every message and deleting the server copy on the way out. The whole archive lives on one machine. Nowhere else. No backup.
That's a mailbox protocol decision, and usually nobody made it on purpose. A setup wizard picked a default and everyone moved on.
So here's the matrix — IMAP vs POP3 vs JMAP vs Exchange, side by side.
There are four mailbox access options worth comparing in 2026, and they're not equally alive.
POP3 and IMAP are the old open standards — 1996 and 2003 respectively, if you go by the RFCs most servers actually implement. JMAP is the modern replacement that a standards body blessed in 2019 and almost nobody has shipped. Exchange isn't really a protocol at all; it's a Microsoft product that speaks a family of proprietary protocols, and it's the reason a huge share of corporate email works the way it does.
Four options. One of them has broad client support.
Webmail isn't on this list on purpose. Webmail is an application, not a mailbox access protocol — behind Gmail's web UI there's a private API doing the same job IMAP would do. If you can't configure it in Thunderbird, it's not in this comparison. Gmail offers IMAP; it isn't IMAP.
| POP3 | IMAP | JMAP | Exchange (MAPI / EAS) | |
|---|---|---|---|---|
| Spec | RFC 1939 (1996) | RFC 3501 / RFC 9051 (2021) | RFC 8620 + RFC 8621 (2019) | Proprietary, Microsoft-defined |
| Sync model | Download, then usually delete | Server is truth, client mirrors it | State string — "what changed since X?" | Server-authoritative, vendor-defined |
| Offline access | Total. Mail is a local file. | Cached; depends on the client | Full, with much cheaper re-sync | Full, with local cache |
| Push | None. Polling only. | Half — IDLE, one connection per folder | Native to the spec | Yes; ActiveSync was built for it |
| Multi-device | Poor | Good | Good | Good |
| Server cost per client | Low per poll, ugly if polled often | Moderate; long-lived connections | Low; batched + delta sync | Heavy |
| Calendar / contacts | No | No | Specs exist, barely deployed | Yes — that's the whole pitch |
| Client support, 2026 | Universal | Universal | Fastmail plus a handful | Outlook, mobile built-ins |
Read that bottom row twice. It decides more than the seven rows above it.
POP3 does one thing. Connect, list what's on the server, pull it down, optionally delete it, disconnect. There's no concept of a folder on the server, no read/unread state that survives the session, no way for a second device to know what the first one did.
Nearly every POP3 client has a "leave a copy on server" checkbox, and that checkbox is the difference between a mild inconvenience and a lost archive. Left unchecked, the first device to connect wins and everything else gets an empty inbox forever.
But I'd push back on the idea that POP3 is dead. It's the right protocol for a couple of narrow jobs, and it's very good at them. If you want a permanent local archive on hardware you control — pull everything down, keep it forever, don't trust a host to be around in eight years — POP3 does that in about four lines of configuration. Same for a single-purpose machine: a script that turns inbound mail into support tickets doesn't want a synced mirror, it wants to consume messages and be done.
One device, one job, one copy. That's the whole use case, and it's a real one.
IMAP flipped the model. The server holds the mail, the folders, and the flags; clients hold a cache and reconcile against it. Delete a message on your phone and it's gone on your laptop, because both devices are looking at the same authoritative copy.
Two things make IMAP a bit clumsy in practice.
The first is IDLE (RFC 2177), which is how IMAP does push. A client opens a connection to a folder, asks the server to report anything that happens there, and holds that connection open. Works fine. The problem is that IDLE is per-folder — if you want instant notifications on your inbox and three filtered folders, that's four open connections from one device, and mobile radios hate holding four TCP connections open in the background.
The second is that syncing is chatty. To find out what changed, a client fetches flags and UIDs across folders and diffs them locally. CONDSTORE and QRESYNC (RFC 7162) fixed a lot of that for servers and clients that implement them properly, and plenty don't. If a sync feels slow, check whether your client has QRESYNC turned on before blaming the server.
Neither of those is a reason to avoid IMAP. It's the default for a reason — every client on earth speaks it, the bugs have been found, and no vendor owns it. If you're picking a protocol in 2026 and you're not sure, this is the answer, and the burden of proof is on anything else.
JMAP is the one I actually get excited about, which makes what I'm about to say more annoying.
It's JSON over HTTPS. A client sends a request object, the server sends a response object, and you can read both in a browser dev console without knowing anything about mail. Syncing works off a state string — the client sends the last state it saw (say, 4a1f), asks what has changed since, and gets a delta back rather than walking folders comparing flags. Requests batch, so fetching your mailbox list, a thread, and three message bodies is one round trip instead of a conversation. Push is in the spec (push subscriptions plus an EventSource stream, with a WebSocket binding added later in RFC 8887), not bolted on.
Fastmail wrote it, ships it, and runs their own apps on it. They're also the only mainstream host most people can name that offers it. Everyone else is a hobby client, a library, or a proof of concept.
And that's the problem. A protocol's value is roughly the square of how many things speak it, and JMAP is sitting at a very small number. Thunderbird doesn't ship it. Apple Mail doesn't. Outlook certainly doesn't. So you get the better protocol and a client list of one, which means in practice you're choosing Fastmail's apps, not choosing JMAP.
My read: JMAP is technically the right design and I still wouldn't build a business email setup on it in 2026. Ask me again when a second major host ships it.
Exchange is where the comparison stops being apples-to-apples. It's a Microsoft server product that exposes several access methods — MAPI/HTTP for Outlook on Windows, Exchange ActiveSync (EAS) for phones, and historically Exchange Web Services (EWS) for everything programmatic.
What you're actually buying with Exchange isn't mail transport. It's the bundle: mail, calendar, contacts, free/busy lookup, shared mailboxes, and room booking, all in a single account that a phone configures in one screen. That bundle is why Exchange survives in organisations that would otherwise have left years ago. Try telling forty staff they now need a separate calendar app and see how that meeting goes.
The catch is that Microsoft keeps moving the floor. Microsoft has announced the retirement of EWS in Exchange Online, starting 1 October 2026, with Microsoft Graph as the replacement. Basic authentication for these endpoints has been progressively switched off for a while now. If you've got an old script or an integration built on EWS, that's a migration on your calendar whether you planned one or not.
And that's what bugs me about proprietary stacks. Nobody gets to retire IMAP. No vendor has the standing to send you a deprecation notice for an open standard — boring, right up until the week you're rewriting working code because someone else's roadmap said so.
Pricing-wise, Microsoft 365 and Google Workspace both list at $84+/user/yr (entry-tier list prices, September 2026) — both per user, every user, every year. Which is fine at five people and starts to sting somewhere around thirty. (We wrote up that exact comparison against Microsoft 365 if the per-seat maths is what brought you here.)
Mailbox protocol choice changes what a mail host has to run, and that eventually shows up in what you pay.
POP3 is cheap per connection and expensive per habit — a client polling every 60 seconds from four devices is 5,760 pointless connections a day, most returning nothing. Nearly all of them find an empty mailbox and hang up. IMAP with IDLE trades that for long-lived open connections, which is cheaper in bandwidth and more expensive in file descriptors and memory per connected client. JMAP is the efficient one on both counts, which is a large part of why Fastmail built it — once you're the one paying the server bill, delta sync stops being a design preference and turns into a line item. Exchange is heavy by design. It's syncing four data types instead of one.
None of this matters to you directly if someone else runs the server. It matters a lot to whoever prices your hosting.
Solo, one machine, wants a permanent archive: POP3 with "leave a copy on server" checked. Belt and braces.
Literally everyone else doing normal email: IMAP. Phone, laptop, tablet, a second person in the shared inbox — IMAP handles all of it and every client already speaks it. Use port 993 with TLS and 587 for sending; our email ports breakdown covers why those two and not the others.
Developers building a mail client, or people who'll switch hosts for protocol design: JMAP, which today means Fastmail. Go in knowing you're picking their apps too.
Organisations where calendar and contacts have to live in the same account, with room booking and free/busy: Exchange. Pay the per-user cost, and don't let anyone talk you out of it on principle — the free/busy lookup that makes a twelve-person meeting bookable in one click isn't something you reassemble out of IMAP plus goodwill.
Agencies and multi-domain operators: IMAP, and then go argue about pricing models instead of protocols — that's where your money actually is. (Running mail across several domains has its own set of DNS headaches that have nothing to do with any of this.)
IMAP wins, and it's not especially close — not because it's the best-designed protocol here (it isn't, JMAP is) but because it's the only open one that everything speaks. That's the property that matters when you're picking infrastructure you'd like to still be using in 2032.
Which is a deeply unexciting conclusion.
Where I'd give ground: Exchange's bundle is a real advantage, not just inertia, and people who dismiss it usually haven't had to support forty non-technical users. And POP3 deserves better than the eye-roll it gets — it's a fine archival tool that got misapplied as a default for twenty years.
Since it'd be strange to write all this without saying it plainly: JustEmails speaks IMAP, SMTP, and POP3. Not JMAP. Not ActiveSync. No calendar or contacts sync, either — if that's a hard requirement, Exchange-based hosting covers it and we do not and pretending otherwise wastes your week. What you get instead is a different trade entirely. JustEmails is $49 a year, flat, for unlimited custom domains and unlimited mailboxes with a unified inbox across all of them — additional team members are $2 per member per month, and storage beyond the included 10 GB is $99 a year per 100 GB. You're buying out of per-mailbox pricing, not buying a protocol.
Pick the boring protocol. Spend the argument on the pricing model instead.
For most people, no — but it hasn't earned its reputation as dead weight either. POP3 is the right pick in exactly two situations: you want a permanent local archive pulled off a server you don't trust to keep things forever, or you're feeding a single-purpose machine like a ticketing script or an archival box that should own the mail and nothing else should touch it. Everything else — phone plus laptop plus tablet, or more than one person in the mailbox — is an IMAP job. The failure mode that bites people is POP3 with "delete from server" enabled on one device, which quietly turns that device into your only copy.
Three things, mainly. It syncs with a state string, so a client asks "what changed since state 4a1f?" and gets one answer instead of walking folders to diff flags. It batches — you can fetch a mailbox list, a thread, and message bodies in a single HTTPS round trip, which matters a lot on a flaky mobile connection. And push is part of the spec rather than bolted on, so you don't need IMAP's one-long-lived-connection-per-folder IDLE arrangement to get near-instant delivery. It's JSON over HTTPS, so any web developer can read the wire format without learning a 1980s line protocol. The catch is client support, which is still thin.
You need something, and Exchange is the option that bundles it into the same protocol as your mail. The alternative is unbundling: CalDAV and CardDAV are open standards that handle calendar and contacts separately, and most major clients speak them — Apple Calendar, Thunderbird, DAVx5 on Android. So you'd run mail on IMAP and calendar on a CalDAV host, which is two things to configure instead of one. Worth it if you're leaving Exchange to escape per-user pricing. Annoying if you have twelve non-technical staff who just want the invite to show up.
No to both. JustEmails gives you full IMAP, SMTP, and POP3 access on the $49/year plan, and that covers every standard mail client — Thunderbird, Apple Mail, Outlook, mobile built-ins. There's no JMAP endpoint and no ActiveSync, and there's no calendar or contacts sync either. That's a real limitation and worth knowing before you switch. If ActiveSync-style calendar-and-contacts-in-one-account is a hard requirement for your team, Exchange-based hosting is the honest answer and we're not the right fit.
Unlimited custom domain email hosting for $49/year flat — unlimited domains, unlimited mailboxes, 10 GB storage, full IMAP/SMTP. Built for agencies, freelancers, and anyone managing email across more than one domain.