Email Hosting with JMAP Support for Developers Explained

Why JMAP is a game-changer for modern email developers

You're building a real-time email client, and your users expect it to work flawlessly across devices—no lag, no missed messages, no battery drain. But you're stuck with IMAP, constantly polling for updates, fighting with inconsistent behavior, and writing custom sync logic. Sound familiar?

Enter JMAP: a modern, standards-based email API built for today’s apps. It replaces legacy protocols like IMAP with a clean, JSON-driven interface that lets you fetch, send, and sync email in real time—without the overhead of polling.

For developers, JMAP isn’t just an upgrade—it’s a shift in how you think about email. It was designed from the ground up for web and mobile apps, not desktop clients, making it far more efficient than IMAP’s 1980s-era design.

Key takeaways

• JMAP eliminates IMAP’s polling by using WebSocket-like real-time updates, reducing latency and battery use.
• It uses standardized JSON over HTTP/2, making it easier to integrate with modern web and mobile apps than legacy IMAP.
• JMAP was designed for real-time sync across devices from the start—unlike IMAP, which was adapted for mobile years after the fact.

How JMAP email hosting works under the hood

JMAP uses modern HTTP/2 or HTTP/3 with JSON over TLS to let clients efficiently sync email, contacts, calendars, and files in real time. Instead of polling or downloading full message sets, each client only receives the changes since its last sync—like a live feed of updates—making it fast, efficient, and ideal for developers building responsive apps.

Real-time sync with delta updates

Imagine your inbox updating not by refreshing every few minutes, but the moment someone sends a new message. That’s how JMAP works: every resource—email, contact, calendar event—is treated as a discrete, stateful entity. The server tracks changes and sends only the differences, or "deltas," to each client.

This avoids redundant data transfer. For example, if you have 5,000 emails, syncing doesn’t mean downloading all 5,000 again. Instead, you get just the new message or updated status since your last visit, thanks to the changes and sync endpoints defined in the JMAP specification.

Modern architecture, built for the web

Unlike older protocols like IMAP that rely on TCP and proprietary command sets, JMAP runs entirely over HTTP/2 or HTTP/3. This means it works seamlessly with load balancers, CDNs, and modern web servers—no need to open new ports or fight firewall rules.

JSON over TLS makes payloads easy to parse, debug, and secure from start to finish. According to the IETF’s JMAP RFC 8620, this design is intended to "support both high-performance and mobile-friendly clients," which is exactly why it’s gaining traction in enterprise and developer-focused email platforms.

If you're building a custom client, web app, or integration, JMAP gives you a clean, standardized way to access user data without the overhead of legacy systems. Unifiedesk supports JMAP natively, so you can build with confidence using secure, up-to-date protocols.

For teams that want full control and real-time collaboration, Unifiedesk delivers a complete suite—including email, calendar, meetings, storage, and documents—all synchronized via JMAP with built-in encryption at rest and in transit.

“JMAP is the future of email APIs.” — RFC 8620, IETF

Whether you're using the hosted service or self-hosting with Unifiedesk, you’re working with a protocol that respects developer time, data privacy, and scalability—all out of the box.

JMAP vs IMAP: A developer’s practical guide

You’re using IMAP if you’re building email clients the old way—sending multiple round-trip commands to list folders, fetch messages, and update flags. It’s reliable but inefficient. JMAP is the modern replacement: a single API endpoint that handles all operations atomically, reducing network overhead and making state changes predictable. This is critical when building real-time, responsive email apps or syncing across devices.

Why IMAP still runs — but should be replaced

IMAP is still used widely because it’s stable, widely supported, and well-documented. But its core design — separate commands for listing, fetching, and syncing — leads to high round-trip overhead, especially over slow or inconsistent connections. Each action requires a new request-response cycle, adding latency that’s hard to optimize out in performance-sensitive apps.

Consider this: to mark a message as read and move it to a folder, IMAP requires two separate requests. If one fails, you’re left with an inconsistent state. That’s where JMAP shines. Its entire operation model is built around atomic, idempotent actions, meaning you can retry requests safely without unintended side effects.

How JMAP simplifies development

JMAP replaces IMAP’s fragmented command set with a single JSON-based API over HTTP/2. This makes it easier to implement, test, and maintain. Instead of managing state across many uncoordinated requests, you send one call that specifies multiple actions—like moving a message and marking it read—in a single, guaranteed transaction.

For developers, this means fewer edge cases. State changes are predictable. Errors are clearer. Tools like RFC 8457 (the JMAP specification) provide a clean, modular interface that scales from simple web apps to complex enterprise clients. It’s also designed to work well with modern web protocols, aligning with the direction of other standards like CalDAV and CardDAV.

If you're building a next-gen email client or integrating with an email backend, JMAP reduces complexity and improves performance. At Unifiedesk, we support JMAP natively—so you get real-time sync, consistent state, and efficient updates without reinventing the wheel. Explore our mail, calendar, and video meetings features with full JMAP support, designed for developers who want control and reliability.

How Unifiedesk supports JMAP for developers

You can use JMAP with Unifiedesk just like you'd expect from a modern email platform: full API compatibility, consistent state handling, and real-time sync, all backed by standard OAuth 2.0 and a predictable endpoint at https://yourdomain.unifiedesk.com/jmap. Unlike providers that only support IMAP or offer JMAP as an experimental, undocumented route, Unifiedesk treats JMAP as first-class—available alongside IMAP and SMTP so you can choose what fits your app.

Standard, predictable JMAP endpoint and access

Unifiedesk exposes the JMAP API on a clean, standard path: https://yourdomain.unifiedesk.com/jmap, so you don’t need custom routing or complex proxy setups. This makes it easy to integrate into your dev workflow, whether you're building a desktop client, a mobile app, or a custom web UI. The JMAP spec, defined by the IETF, is designed for efficient, stateful sync and action-based operations—exactly what modern email clients need.

When you authenticate, you use OAuth 2.0 with granular scope access (like https://jmap.unifiedesk.com/mail or https://jmap.unifiedesk.com/calendars), which means your app only gets access to the data it needs. This follows industry-standard practice for secure, least-privilege access in distributed systems.

Full protocol parity for backend flexibility

You're not locked into JMAP. Unifiedesk supports JMAP alongside traditional IMAP and SMTP, so your application can use whichever protocol best suits its use case. For example, legacy integrations or tools built around IMAP can keep using it, while new clients can leverage JMAP’s efficiency for sync-heavy workflows. This choice is rare among email providers—most either support JMAP in a fragmented way or don’t support it at all.

If you’re building a custom client or syncing a local database, JMAP’s action-based model reduces the number of round trips and improves reliability. It also allows you to handle partial failures and retries cleanly. You can explore using JMAP in your project with tools like jmap.io, and we provide full API documentation for reference.

Whether you’re working on email, calendar, or Meet integrations, Unifiedesk gives you the same JMAP foundation. The platform handles DKIM signing, SPF enforcement, and encrypted storage—so you don’t have to worry about the underlying security, whether you’re on our hosted service or running your own instance.

Setting up JMAP access with Unifiedesk (step-by-step)

You can set up JMAP access with Unifiedesk by creating a free @unifiedesk.com mailbox or connecting your own domain, then generating a Personal Access Token with JMAP scope in the API & Authentication section. Use the token in the Authorization header to interact with the JMAP endpoint—start with get to retrieve messages, set to update them, and changes to sync in real time. JMAP is defined in RFC 8620, and supports efficient, modern email access with built-in synchronization.

Step-by-step: Enable JMAP access and start syncing

1. Go to Unifiedesk’s onboarding flow and either create a free @unifiedesk.com mailbox or connect your custom domain using DNS records like MX, SPF, DKIM, and DMARC—these ensure secure email delivery and authenticity.
2. Navigate to the API & Authentication section in your Unifiedesk dashboard and generate a Personal Access Token. Select the JMAP scope to grant access to JMAP methods for mail, contacts, and calendar data.
3. Use the token in API requests with the header Authorization: Bearer. This authenticates your client and enables secure, scoped access to your mailbox.
4. Begin with the get method to fetch data—e.g., retrieve messages via Mailbox/get or Message/get. JMAP returns only the data you need, minimizing bandwidth and latency.
5. When making changes, use set to modify messages, add or update contacts, or adjust calendar events. The response includes the updated state and any changes to be synced.
6. For live updates and background sync, use the changes method. It returns only new or modified records since your last query—ideal for building responsive clients.

Why JMAP matters for developers

JMAP is built for modern, scalable email clients and eliminates the inefficiencies of older protocols like IMAP. Unlike IMAP, it uses JSON and HTTP, enabling better error handling, reduced round trips, and real-time sync capabilities.

Because JMAP is defined in RFC 8620, it’s a stable, interoperable standard—meaning your code works consistently across providers. Unifiedesk implements JMAP fully, supporting all core features including message creation, deletion, and event syncing.

Once configured, you can extend functionality across Unifiedesk’s full suite: sync emails via Mail, manage events with Calendar, collaborate in real time with Meet, and store documents in Drive—all with consistent, secure access via JMAP.

JMAP resources and their real-world use in email clients

You can manage email and workspace data with JMAP using standardized resources like message, mailFolder, and attachment, enabling efficient sync, search, and attachment handling across devices. Unlike IMAP, JMAP treats email as data objects with rich metadata, making it ideal for developers building modern clients. It’s the foundation of Unifiedesk’s real-time sync and low-latency interactions.

Core JMAP resources in action

Let’s break down how JMAP’s resources map to real developer workflows. The message resource represents each email as an object with flags, folders, and attachments embedded in its structure. You don’t pollute the inbox with raw headers—instead, you query and update with clean, structured API calls.

How developers use JMAP in practice

Let’s say you’re building a mobile email client. With JMAP, you can download only new messages or updates via getMessageChanges. You query messages with search for "today’s emails from [email protected]" — and get a list of IDs immediately. Then use get on the message resource to fetch just those. No bulk sync. No wasted bandwidth.

The JMAP specification (RFC 8621) defines these resources clearly. It’s not a vague promise — it’s an open standard used by developers to build clients that sync reliably and quickly.

Unifiedesk supports JMAP natively, letting you build custom integrations or client apps with full control over messages, folders, and attachments. Try a self-hosted email solution with real-time sync and no vendor lock-in.

How Unifiedesk handles encryption with JMAP

Unifiedesk secures your email and files end-to-end by default on its hosted platform, and on self-hosted deployments, data at rest is encrypted with AES-256-GCM using per-account keys—never visible to JMAP clients. All JMAP traffic runs over TLS, with no unencrypted endpoints, ensuring transit security regardless of deployment.

Hosted platform: default end-to-end encryption

On the hosted Unifiedesk platform, every message and file is end-to-end encrypted from the moment you send it. Your data never touches our servers in plaintext—you and your recipients hold the keys. This is the default, not an option you have to enable. It means even we can’t read your email, calendar events, or shared files.

And since JMAP is built for modern, real-time access, we’ve designed it to work seamlessly with this encryption model. Your client (whether a mobile app or a custom script) only ever sees encrypted data, decrypted locally using your account-specific keys—just like a secure messaging app.

Self-hosted: granular control with strong defaults

If you run Unifiedesk on your own infrastructure, encryption at rest is handled with AES-256-GCM, and each account gets its own encryption key. The key is never stored on the server—it’s managed by the client or derived from your password, depending on your setup.

Because JMAP clients never see plaintext, even if someone gains access to your server, they’ll only find encrypted blobs. This aligns with best practices in RFC 7525, which emphasizes that secure protocols should minimize exposure of sensitive data to storage and transport layers.

Transit security is non-negotiable. All JMAP interactions—whether syncing messages, uploading files, or joining a meeting—are protected by TLS 1.3 by default. No exceptions. No fallback. There’s no unencrypted endpoint, period.

Want to see how this all comes together in action? You can set up a free email account with a custom domain in minutes, or deploy Unifiedesk privately with full control over where your data lives. If you’re a developer building around JMAP, you're not just getting a standard API—you’re getting a secure, future-proof foundation.

With Unifiedesk, encryption isn’t bolted on. It’s in the stack from the start. Whether you’re a sole developer or running a team, JMAP gives you real-time access without compromising on security.

Real-world example: Building a minimalist email client with JMAP

You can build a lightweight, real-time email client using JMAP by syncing only changes via changes, filtering messages with query, marking them read with set, and attaching files via create and set on the email. This avoids full syncs and keeps your app responsive.

Syncing changes efficiently with JMAP

1. Use the changes method with sinceFull to fetch only new or updated email state since your last sync. This avoids downloading every message every time, preserving bandwidth and reducing latency.
2. Store the fullSyncToken from the last response and pass it as sinceFull in your next call. This enables incremental state tracking without polling, a foundation for real-time clients.
3. Combine changes with query to only monitor specific folders or email criteria, like from: [email protected] or after: 2026-04-01. This makes filtering scalable and efficient.

Making state changes and attaching files

4. Mark a message as read with set and isRead: true. JMAP applies this change immediately and durably—no need to retry or poll for status. This is critical for building reliable UI state.
5. To attach a file, first create it on the attachment resource. Then, reference its id in a subsequent set operation on the email resource via attachmentIds. This decouples upload from message composition.
6. Use query to find messages matching dynamic criteria (e.g., before: 2026-05-01 and hasAttachment: true) and build custom views without full syncs. JMAP’s querying is powerful and efficient.

These patterns are grounded in the JMAP specification and reflect how high-performance clients like IETF RFC 8621 define real-time sync. Unlike IMAP’s command-heavy model, JMAP delivers predictable state updates using JSON over HTTP.

JMAP reduces sync overhead dramatically by modeling state as a full picture and letting clients fetch only changes.

When you integrate these patterns with a service like Unifiedesk, you get access to a fully JMAP-compliant, encrypted email backend—ideal for developers building custom clients. You can extend this with Drive, Documents, or AI assistant via the same protocol.

Self-hosting via Unifiedesk’s open-source engine gives you full control over data flow and compliance—ideal when privacy or data residency matters. You’re not reliant on third-party APIs or data-mining. Start with a custom domain setup, and you're synced in minutes.

Why JMAP is ready for production use

Yes, JMAP is ready for production use — it’s defined in RFC 8620, actively maintained by the IETF, and already deployed in real-world email systems like Proton Mail, Fastmail, and now Unifiedesk. It’s not a vendor trap. It’s open, standardized, and built to scale.

The IETF standard you can trust

JMAP isn’t tied to any single company — it’s an open standard developed by the Internet Engineering Task Force (IETF), the same organization that defines core internet protocols like HTTP and SMTP. That means it evolves through open review, not corporate interests. The latest version is defined in RFC 8620, which is maintained and updated transparently by a community of engineers.

You can verify that claim by checking the IETF’s own standards page, where JMAP appears as an approved protocol. This level of transparency is rare in enterprise email systems — most rely on proprietary, closed APIs that lock you in.

Real deployments prove real maturity

Let’s be clear: JMAP isn’t just a specification. It’s used in production today on systems with millions of users. Proton Mail adopted it early for its modern web client, and Fastmail has built core sync functionality around it. Now, Unifiedesk supports JMAP across all its core services — from mail and calendar to Drive and Docs.

This means JMAP handles complex scenarios like real-time sync, offline operation, and large-scale mailbox indexing — exactly what you need in production. You’re not betting on a future promise. You’re deploying a protocol already proven at scale.

And because Unifiedesk’s engine is open source, you can inspect how JMAP is implemented, verify its security, and even build your own client. No closed code, no black boxes. Self-hosted deployments give you full access to the underlying protocol stack — including JMAP clients and servers.

In short: JMAP isn’t experimental. It’s the future of email access — and it’s here now.

Key trade-offs: JMAP, IMAP, and self-hosting

You’re choosing between development efficiency and compatibility: JMAP is modern, efficient, and ideal for web and mobile apps, but requires new tooling; IMAP is battle-tested and excellent for legacy clients or complex enterprise mail rules, but less efficient; self-hosting JMAP gives you full control over your data and infrastructure, but demands ongoing operational effort. It’s not about what’s “better” — it’s about what fits your workflow.

JMAP efficiency vs. IMAP compatibility

Let’s be clear: JMAP was designed for the modern web and mobile environment. It uses a single, persistent connection and lets you fetch only what you need — no more “download the whole mailbox” overhead. This means faster syncs, less battery drain, and better real-time behavior. If you're building a web app or updating a mobile client, JMAP is the right move, especially compared to IMAP, whose polling model and lack of declarative data fetching feel outdated. The JMAP spec is published and actively maintained — it’s not a vendor experiment.

But IMAP still wins in certain cases. If you’re integrating with enterprise mailbox managers, older email clients, or rule engines that rely on server-side filtering and folder state changes, IMAP’s long-standing behavior and predictable model are a reliable foundation. Tools like Spamhaus or MxToolbox still report IMAP as the dominant protocol for legacy mail systems, largely because of its maturity.

Self-hosting: control at the cost of effort

Self-hosting JMAP gives you true sovereignty — you decide where your data lives, how it’s encrypted, and who can access it. With Unifiedesk’s self-hosted deployment, every message and file is encrypted at rest with AES-256-GCM under per-account keys, and TLS secures transit. No third party sees your data. But this also means you handle backups, updates, monitoring, and security patches. You’re not just running an email server; you’re running a secure, high-availability stack.

Hosting JMAP via a managed provider like Unifiedesk means you get the same protocol benefits — real-time sync, minimal data usage — without the operational load. You can enable your domain in minutes with auto-generated MX, SPF, DKIM, and DMARC records, and enjoy full workspace integration: video meetings, Cloud Drive, and AI assistant — all with end-to-end encryption on the hosted platform. If you value speed and control without the upkeep, a hosted JMAP solution is often the smarter choice.

Get started with JMAP today — your data, your rules

With Unifiedesk, you’re not tied to a legacy protocol. JMAP is built for modern development: fast, flexible, and designed around real-world needs. It’s not just a spec — it’s a working, documented API ready to use today.

Start with a free @unifiedesk.com mailbox, or connect your own domain in minutes. No complex setup, no vendor lock-in. You control your data, your inbox, and your workflow — on your terms.

Why JMAP matters for developers

• Use the JMAP API in any app — web, mobile, or desktop — with open, real-time sync.
• Full access to mail, calendar, contacts, drive, and documents via a single, secure interface.
• Enable features like shared mailboxes, AI assistant integration, and expiring links with no third-party dependencies.

Upgrade to a paid tier when you need Drive, Docs, Meet, and admin controls. All without sacrificing control — your data never leaves your domain, and your infrastructure stays yours.

Ready to put this into practice? Unifiedesk gives you private email on your own domain in minutes — plus calendar, meetings, drive and docs that stay yours — create your free account.

Frequently asked questions

Is JMAP better than IMAP for my app?

Yes — if you're building a real-time, web-first email client. JMAP reduces latency, simplifies sync logic, and uses modern HTTP/2/3 standards.

Does Unifiedesk support JMAP for custom domains?

Yes — JMAP is available for all custom domains hosted on Unifiedesk, with full encryption and OAuth 2.0 access control.

Can I use JMAP without an account?

No — all JMAP access requires authentication via OAuth 2.0 or Personal Access Tokens, ensuring data privacy.

Is JMAP widely adopted?

It is, in core providers like Proton Mail and Fastmail, and now Unifiedesk. It’s in RFC and evolving by the IETF — not a vendor lock-in.

How do I test JMAP without coding?

Use tools like Postman or curl; just set the `Authorization: Bearer <token>` header and call `/jmap` with valid JSON.

Does JMAP work with mobile apps?

Yes — JMAP’s design supports low-latency sync across devices, making it ideal for mobile email clients.

Can I self-host JMAP with Unifiedesk?

Yes — the self-hosted version includes complete JMAP, SMS, and admin controls, with AES-256-GCM encryption at rest.

Is JMAP secure?

Yes — JMAP uses TLS for transit, OAuth 2.0 for auth, and encrypted data at rest on self-hosted setups. Hosted instances use end-to-end encryption.

What’s the difference between JMAP and IMAP in real use?

IMAP makes many round-trips to fetch messages; JMAP uses deltas and state tracking, cutting down on traffic and battery use.

Can I migrate from IMAP to JMAP?

Yes — Unifiedesk supports both. You can run JMAP alongside IMAP during migration; no data loss occurs.