EmailEngine Review 2026: $1,450 a Year Self-Hosted Email API

EmailEngine review 2026: what $1,450 a year buys, how the self-hosted API syncs Gmail, Outlook and IMAP, and the limits that bite in production.

Published Updated 18 min read
EmailEngine Review 2026: $1,450 a Year Self-Hosted Email API

EmailEngine is a self-hosted email API. You run it next to a Redis database, register your users' Gmail, Microsoft 365 or IMAP accounts, and get one REST API and one stream of webhooks across all of them. It costs $1,450 or €1,200 a year for unlimited mailboxes, which undercuts per-account APIs such as Nylas once a product connects more than about 60 mailboxes. The catch is that you operate it: a service that cannot run as two replicas, a Redis you have to treat as a database, and a Google verification process that your choice of Gmail backend decides.

We read EmailEngine's documentation, its API reference, its license and its changelog up to version 2.82.2, released on 5 October 2026, along with the Google and Microsoft pages that set the limits it runs under, and rechecked the sending and webhook behaviour against version 2.85.0, released on 20 October 2026. The features match what the homepage promises. What the homepage does not tell you is how the thing behaves: reads go to the mail server live, history is not replayed as webhooks, and several reliability fixes shipped only in the last few weeks. That behaviour is what this review covers.

How does EmailEngine work?

EmailEngine keeps a live connection to every mailbox you register and translates REST calls into IMAP, SMTP, Gmail API or Microsoft Graph operations. The easiest way to understand it is to follow one mailbox from registration to its first webhook.

Registering a mailbox

For a plain IMAP account, one call registers the mailbox with its IMAP and SMTP settings. This is the example from EmailEngine's documentation:

Register an IMAP and SMTP account (EmailEngine docs)
curl -X POST https://emailengine.example.com/v1/account \
 -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
 -H "Content-Type: application/json" \
 -d '{
 "account": "user123",
 "name": "John Doe",
 "email": "john@example.com",
 "imap": {
 "host": "imap.example.com",
 "port": 993,
 "secure": true,
 "auth": { "user": "john@example.com", "pass": "password" }
 },
 "smtp": {
 "host": "smtp.example.com",
 "port": 587,
 "secure": false,
 "auth": { "user": "john@example.com", "pass": "password" }
 }
 }'

The response is only the account id and a state of new or existing. EmailEngine does not check the credentials during that request, so a wrong password shows up later as an authenticationError or connectError webhook, unless your signup flow tests the credentials first with the separate POST /v1/verifyAccount call. For Gmail and Microsoft 365, you would rather not handle passwords at all: POST /v1/authentication/form returns a link to a hosted OAuth2 page, single-use and valid for 24 hours, and EmailEngine stores and refreshes the tokens.

Staying in sync

On the IMAP backend, EmailEngine opens one connection per account and keeps it in IDLE on the inbox, or on All Mail for a Gmail account, so new mail there is pushed as it arrives. Every other folder is polled, and a full resync runs every 900 seconds by default. If your product needs push on another folder, Sent on a non-Gmail server for example, you can add a sub-connection for it, but each one is another IMAP session counted against the provider's cap. On Gmail, All Mail already covers Sent, and only Trash and Spam can get a sub-connection.

Redis holds the index, not the mail. The documentation says each message takes one small entry, and that message bodies and attachments are not stored but fetched from the mail server on request. Message listings and headers are fetched live too, every time your code asks for a page. That design keeps mail content off your servers, which is why many buyers choose it, but it has a cost the vendor states plainly: every read is a round trip to the mail server, and on IMAP, requests for the same mailbox queue behind each other on that one connection. A screen that lists a user's messages and then opens a few of them costs one round trip to the mail server per request, and on an IMAP account those requests run one after another for that mailbox, never as a query on your own database.

The first webhook

When a new message lands, EmailEngine posts a messageNew webhook. Trimmed to its main fields, the documented example looks like this:

messageNew webhook, trimmed (EmailEngine docs)
{
 "serviceUrl": "https://emailengine.example.com",
 "account": "user123",
 "date": "2025-10-17T06:42:25.056Z",
 "path": "INBOX",
 "event": "messageNew",
 "data": {
 "id": "AAAADAAABy4",
 "uid": 1838,
 "path": "INBOX",
 "unseen": true,
 "subject": "Quarterly Report Review",
 "from": { "name": "John Smith", "address": "john.smith@example.com" },
 "to": [ { "name": "Jane Doe", "address": "jane.doe@company.com" } ],
 "messageId": "<abc123@mail.example.com>",
 "text": {
 "plain": "Hi Jane,\n\nPlease find attached the Q3 report for your review.\n\nBest regards,\nJohn"
 },
 "seemsLikeNew": true
 }
}

Three details about webhooks catch new users. The list of events to deliver is an allowlist with no default, so an instance where nobody set webhookEvents delivers nothing at all. The message text is included in the payload by default, up to 2 MB per part, which means mail content does leave EmailEngine, to your endpoint, on every new message. And EmailEngine keeps no delivery log: a webhook gets 10 delivery attempts with exponential backoff, 4xx responses included, then the job moves to a failed queue that keeps, by default, the last 500 failures for 7 days for a manual retry. Your endpoint has to persist what it receives, and verify the HMAC-SHA256 signature in the X-EE-Wh-Signature header.

What happens to the mail that was already there

Nothing, by default. On IMAP, messageNew only fires for mail received after the account was registered, and the existing mailbox is indexed silently, one Redis write per message, until an accountInitialized webhook says the first sync is done. You can replay an IMAP mailbox as webhooks by flushing the account with an old notifyFrom date. Gmail API and Microsoft Graph accounts ignore that setting and never replay history, so a CRM that wants two years of correspondence has to page through the message list itself, using the \All path.

What does sending through EmailEngine look like?

You post JSON and EmailEngine builds the MIME message, sends it through the account's own SMTP server or provider API and handles the threading headers when you reply. The quick-start example:

Send a message (EmailEngine docs)
curl -XPOST "http://localhost:3000/v1/account/my-account/submit" \
 -H "Authorization: Bearer ${EMAILENGINE_TOKEN}" \
 -H "Content-Type: application/json" \
 -d '{
 "to": [{ "name": "Test Recipient", "address": "recipient@example.com" }],
 "subject": "Test email from EmailEngine",
 "text": "Hello! This is my first email sent through EmailEngine."
 }'

The answer is "Queued for delivery" with a queueId, and the documentation is explicit that a 2xx means queued, not sent. The outbox makes up to 10 delivery attempts on a retriable failure, with exponential backoff from 5 seconds, which means a message that keeps failing is abandoned about 43 minutes after the first attempt. A 5xx reply from the server is treated as permanent, except 503, and every 4xx is retried. The outcome comes back as a messageSent, messageDeliveryError or messageFailed webhook, and bounces and complaints that arrive later as messageBounce and messageComplaint.

Replies and forwards use a reference object that points to a message already in the mailbox, and EmailEngine sets In-Reply-To and References from it. A sendAt field schedules a message, and an Idempotency-Key header, scoped to the account, stops a retried request from sending twice. On SMTP accounts, EmailEngine uploads a copy to the Sent folder, except on Gmail and Microsoft, whose servers file it themselves. Once a message is sent, its content is deleted from Redis, so there is no sent archive either; since version 2.84.0, the last 100 failed messages keep their content by default, so they can be retried with POST /v1/outbox/{queueId}/retry.

The default throughput surprises people building anything with volume. The sending queue and the webhook queue each run with one worker processing one job at a time, and the docs warn that events can reach your endpoint out of order with any configuration. Both queue settings are ones you will change, and both have consequences you have to handle.

Which EmailEngine backend should you use for Gmail and Microsoft 365?

The choice of backend decides your OAuth scopes, and for Gmail, the scopes decide how much of Google's verification you go through. EmailEngine added a Gmail API backend in 2024 (version 2.43.0) and a Microsoft Graph backend in August 2024 (2.44.0), next to the original IMAP and SMTP route:

BackendScope or setupChange notificationsWhat to know
Gmail over IMAP and SMTPThe full https://mail.google.com/ scope, restrictedIDLE on All MailEmailEngine's own docs say Google will likely reject this scope for a public app unless it needs permanent deletion
Gmail APIgmail.modify by default, also restrictedGoogle Cloud Pub/Sub, pulled by EmailEngine, plus a service accountWithout Pub/Sub, accounts are polled about every 10 minutes. Deleting always moves to Trash.
Microsoft GraphGraph mail permissions in your Azure appGraph subscriptions pushed to two public HTTPS endpointsAn instance on a private network needs a reverse proxy or a tunnel. In its default mode, search cannot filter on to, cc, bcc, body or size
Microsoft IMAP and SMTPOAuth2 only for IMAPIDLEBasic authentication for IMAP is already off, and Microsoft turns SMTP AUTH basic authentication off by default for existing tenants at the end of December 2026

For Gmail, the verification is the long pole. Both Gmail routes use restricted scopes: the IMAP route needs the full mail.google.com scope, and the Gmail API route uses gmail.modify by default, both on Google's restricted list along with gmail.readonly. Only gmail.send, for an app that sends and never reads, is classed as sensitive instead. Whatever backend you pick, the Google side of the work is the same, and EmailEngine does none of it for you. What going direct involves, from the consent screen to push notifications, is in our Gmail API guide.

What does Google's OAuth verification involve, step by step?

Google's help center lays out the sequence for an external app that reads Gmail, and each step has its own wait:

  1. Set up the OAuth consent screen: app name, support email, logo, a homepage on a domain you have verified in Google Search Console, a privacy policy that says how Google user data is accessed, used, stored and shared, and terms of service. External apps start in testing.
  2. Pass brand verification. Google's FAQ gives 2 to 3 business days, while its newer branding page says the automated check usually takes minutes, and the branding must be published before you can ask for scope verification.
  3. Submit the scopes. For each one, explain why a narrower scope would not work, and record a demo video, on YouTube, Google Drive or any accessible link, that shows the full OAuth flow, the consent screen with the exact scopes, and how the app uses each scope. Reviewers also need a test account to log in with.
  4. Pass the security assessment. For restricted scopes it comes last, when Google's Trust and Safety team says to start. It follows the App Defense Alliance's CASA framework, based on OWASP ASVS, run by an authorized lab at an assurance level Google assigns, and the old self-scan route is marked deprecated. Google charges nothing for it, and the lab's fee is agreed privately.
  5. Recertify every 12 months from the approval date of your last Letter of Assessment, with a full retest whether or not the app changed.

Google's FAQ estimates 10 business days for sensitive scopes and about six weeks for restricted ones, assessment included, without guaranteeing either. Until the app is verified, users see an unverified-app warning and the project is capped at 100 new users over its lifetime, a counter that never resets, and if the project stays in testing status, refresh tokens expire after 7 days, so test users get disconnected every week.

There are narrow ways around it. An internal app used only inside your own Google Workspace organization is exempt. A customer's Workspace administrator can mark your app as trusted for their domain, which Google's help center lists as exempt, although Google's restricted-scope page says domain-wide installs using restricted scopes still need verification. And a send-only app on gmail.send needs only the lighter sensitive-scope review, with no security assessment. Anything else that reads Gmail for users outside your organization goes through the assessment, unless it runs on a provider's Google app that is already verified. Our guide to Nylas pricing explains how Nylas sells its pre-verified Google app as an add-on, the main way a managed API shortens this step.

Verification also binds you to Google's rules on how the data is used, which matter for AI products in particular. Google's Workspace data policy limits Gmail data to the user-facing features the app requested it for, forbids letting people read it without the user's explicit consent, forbids using it for ads, and forbids using it to create, train or improve an AI model beyond that specific user's personalized model. The same policy requires OAuth tokens to be encrypted at rest and, for apps that run AI on the data, protection against prompt injection.

Which Gmail tokens break after launch?

Even a verified app loses connections in ways that look like random failures unless you know Google's rules. From Google's OAuth documentation:

What happensGoogle's ruleWhat your app should do
An older connection for the same user stops workingEach Google account can hold 100 refresh tokens per OAuth client, and a new one silently invalidates the oldestReuse the stored token instead of sending users through consent again
A mailbox disconnects after the user changes their passwordA password change revokes refresh tokens that carry Gmail scopesCatch the authenticationError webhook and send the user back through the hosted form
A mailbox switched off for months cannot reconnectA refresh token unused for six months expiresSend the user through the hosted form again instead of retrying the old token
A whole customer domain fails with admin_policy_enforcedA Workspace admin restricted Gmail to trusted apps, and Gmail's high-risk scopes, gmail.send included, can be limited that wayAsk the customer's admin to mark your app as trusted

What breaks when you run EmailEngine in production?

Most of the problems in EmailEngine's documentation come from the mail providers, from Redis or from the single-instance design, and each one has a known fix:

What you seeWhy it happensWhat to do
An account stops reporting new mail, with no errorThe IMAP connection stays open while the server's view of the folder stops movingTurn on the stale-connection detector, EENGINE_IMAP_STALE_CHECK_INTERVAL, added in 2.82.0 and off by default
A Gmail account is suspended for 1 to 24 hoursGmail's IMAP bandwidth limit: 2,500 MB of downloads and 500 MB of uploads a day per accountFetch message text only when needed, sync fewer folders, keep heavy readers on the Gmail API backend
"Too many simultaneous connections" from GmailEmailEngine's sessions share Gmail's cap of 15 IMAP clients per account with the user's own phone and desktop mail appsKeep sub-connections to the folders that really need push, and remove IMAP clients nobody uses
Every Microsoft account on the same Azure app fails at its next token refreshThe client secret of your Azure app expired, and the portal allows 24 months at mostRotate the secret on a calendar, before it expires
One account goes silent after a password changeOne authenticationError fires, repeats are suppressed, and after 3 days the account is parkedSend the user back through the hosted form. A reconnect call does nothing on a parked account
Duplicate webhooks and conflicting stateTwo EmailEngine instances pointed at the same Redis databaseRun exactly one replica per Redis, and accept the downtime of a stop-then-start upgrade
Redis runs out of memory, then CPU sits at 100 percentIndexes, queued messages and pending webhooks all live in RedisSize it at 1 to 2 MiB per account and provision double, with the noeviction policy

Two more points belong on the checklist before the first real user connects. Credentials and OAuth tokens are stored in Redis in cleartext unless you set EENGINE_SECRET, so set it on day one. And Redis is a database here, not a cache: EmailEngine supports only the noeviction policy, recommends RDB snapshots rather than AOF, warns that Amazon ElastiCache can lose data and does not support Redis Cluster.

Recent releases matter more than usual, too. Version 2.82.0, on 1 October 2026, removed the Document Store, and with it account-wide search: search now needs a folder, so on a plain IMAP server it runs one folder at a time, while Gmail and Microsoft Graph accounts can still search everything through the \All path. Version 2.82.1, four days later, added the poll that recovers new Microsoft mail whose Graph notification was dropped. Before it, such a message was only announced if a sync ran within four hours. Pin the version you test, and read the changelog before every upgrade.

How many mailboxes can one EmailEngine instance handle?

Several thousand, according to the performance guide, on one well-sized server. Mailbox work runs on account worker threads, 4 by default, so 100 accounts means about 25 per thread, and every API call that touches a mailbox runs on that account's thread. Redis is sized at 1 to 2 MiB per account, provisioned twice over: the documentation's table gives 4 GiB for 1,000 accounts and 40 GiB for 10,000.

Past one instance, there is no cluster mode. You shard: each instance gets its own Redis and its own set of accounts, and your application routes every API request to the instance that owns the account, with no failover between them. Restarts also take time at scale. EmailEngine can pace reconnections with EENGINE_CONNECTION_SETUP_DELAY, which is 0 by default, and its own example says that with a 3-second delay and 1,000 accounts, the last account comes online about 50 minutes after startup, during which API calls for accounts not yet connected fail. Since upgrades stop the old instance before the new one starts, plan them like maintenance windows.

How much does EmailEngine cost in 2026?

EmailEngine sells one subscription. As read on emailengine.app and its license on 8 October 2026:

ItemEmailEngine
Price$1,450 or €1,200 a year, VAT excluded
Mailboxes and instancesUnlimited, for production, staging and development
Serving your own customersAllowed, as long as you manage the instances yourself
Reselling it as a serviceNot allowed: your customers may not build their own services on it
Free trial14 days from the instance dashboard, no sign-up or card
After the trial or a lapsed subscriptionSyncing, sending and webhooks stop. Keys become invalid 30 days after a subscription expires
Perpetual licenseAvailable through sales, verified offline, price not published

The license is a proprietary agreement under Estonian law, not an open-source license, even though the source code is public on GitHub. It caps the vendor's liability at €50 over the life of your usage and does not guarantee support. Subscription keys check in with the vendor at most every 30 days, and a failed network check never suspends an instance.

A flat fee wins once you connect enough mailboxes. Using each vendor's published prices on monthly billing, before hosting:

Connected mailboxesEmailEngineNylas, cheapest planUnipile
10about $121 a month$15 a month (Essentials)$55 a month
25about $121 a month$48.75 a month (Essentials)$137.50 a month
100about $121 a month$199 a month (Pro)$500 a month
500about $121 a month$999 a month (Pro)$2,250 a month

EmailEngine's license costs less than Unipile from 22 mailboxes and less than Nylas from 61, or from 70 against Nylas Pro on annual billing. Unipile earns its higher price only when the same accounts also need LinkedIn or WhatsApp, as our Unipile pricing breakdown and Unipile review explain. Hosting comes on top of the license: a server, a Redis sized as above, monitoring and the hours of whoever runs it. Our LinkedIn API pricing grid lists EmailEngine next to the other APIs developers compare it with.

Who is behind EmailEngine?

One developer. EmailEngine is written by Andris Reinman, the author of Nodemailer, through his Estonian company Postal Systems OÜ, and its about page says plainly that it is not a venture-backed team with a support tier between you and the code. The project has shipped releases every few days since 2020, and its site reports more than 200 companies running it in production across 38 countries.

The one-person model is a strength when you need an answer from whoever wrote the code, and a risk you should price in. GitHub issues are switched off on the repository, although the support page still points bug reports there, so support runs through the vendor directly. The public source code and the perpetual license are the vendor's answers to the question of what happens if the developer stops.

Is EmailEngine a good fit for cold email?

Only as the sending layer underneath a tool you build. EmailEngine sends personalised messages from many mailboxes, schedules them and parses bounces. It does not run sequences, spread one campaign across a pool of mailboxes, cap each mailbox per day, warm mailboxes or stop a sequence when someone replies, and its default sending queue processes one message at a time. Each mailbox also sends under its provider's own limits, such as Exchange Online's 10,000 recipients a day per mailbox and the tenant-wide external cap our guide to Outlook sending limits explains. Our guide to Gmail sending limits covers the caps every Gmail and Workspace mailbox sends under, and the build-or-buy question for the layer on top is what our outreach API comparison walks through. Our Unipile alternatives guide also covers EmailEngine as the email leg of a multichannel stack.

Where does Swarmhit fit?

It sits one layer higher, and it is priced on a different unit. EmailEngine, Nylas and Unipile all sell access: a connection to a mailbox, and the actions you can call on it. What you do with that access, the sequences, the pacing across mailboxes, the caps, the reply handling, stays in your code. Swarmhit is, as far as we know, the only Smart API provider for outreach: the engine runs behind the API. One call creates a campaign with its whole sequence, and Swarmhit spreads the sends across a pool of mailboxes, keeps one mailbox per lead for the whole thread, applies per-mailbox daily caps and sending windows, suppresses hard bounces and spam complaints and stops a sequence when someone replies. The same campaign can mix email steps with LinkedIn steps.

The pricing follows from that. Mailbox APIs charge for what you connect: a license per company on EmailEngine, a fee per connected account on Nylas and Unipile. Swarmhit's cold email charges for what you send, with unlimited mailboxes: $59 a month for the first 125,000 sends, then per 1,000 emails sent, so 250,000 sends cost $89. Every email sent through Swarmhit counts toward the plan, warmup emails you send included. For a team that sends 50,000 cold emails a month from 100 mailboxes, that is the difference between paying for volume and paying for inboxes:

What you pay for50,000 sends from 100 mailboxesWhat you still build
EmailEngineA license per company, plus your serversAbout $121 a month, plus hostingSequences, rotation, caps, warmup, reply detection, and running the service
Nylas ProEach connected mailbox$199 a monthSequences, rotation, caps, warmup, reply detection
UnipileEach connected account$500 a monthSequences, rotation, caps, warmup, reply detection
Swarmhit Smart APIEmails sent, unlimited mailboxes$59 a month, cold emailYour product on top

The bill stays at $59 whether those 50,000 sends come from 20 mailboxes or 200. That is where volume pricing and per-mailbox pricing pull apart: adding mailboxes to spread the load, the safe way to send cold email, costs nothing extra. On the mailbox side, you connect your own Google, Microsoft or IMAP mailboxes, or buy a domain and Google Workspace or Microsoft 365 mailboxes through Swarmhit that arrive connected and already warming. LinkedIn is priced separately, per connected sender, from $16.90 a month.

The two still answer different needs. If your product needs the inside of a mailbox, a support queue, a CRM timeline or an agent reading threads, EmailEngine is the better tool. If what you need is outreach that runs from email and LinkedIn in the same sequence, the Swarmhit cold email API covers it without the engine to build. Our Swarmhit vs EmailEngine comparison lines the two up feature by feature.

Run outreach, not a mailbox gateway

Swarmhit's Smart API runs email and LinkedIn steps in one campaign, with mailbox pools, per-mailbox caps, bounce suppression and reply webhooks already built.

Cold email from $59 a month for 125,000 sends; LinkedIn from $16.90 per sender a month, tiered down to $6.90.

FAQ

How much does EmailEngine cost?

EmailEngine costs $1,450 or €1,200 a year, VAT excluded, for one company. That covers unlimited mailboxes and instances, and the license lets you serve your own customers from instances you manage, so a CRM with a thousand client companies still pays once. A perpetual license, paid once and verified offline, is sold through the vendor at a price it does not publish. Hosting and Redis are not included.

Does EmailEngine store my users' emails?

Not the content. Redis holds an index with one small entry per message, and bodies and attachments are fetched from the mail server each time you request them. Two things do pass through or stay on your side: outgoing messages sit in Redis until they are sent or finally fail, with the last 100 failed ones keeping their content by default since 2.84.0, and webhooks carry the message text to your endpoint by default. Credentials sit in Redis in cleartext unless you set EENGINE_SECRET.

Does EmailEngine need Google verification for Gmail?

Your app does, if it reads Gmail for users outside your organization. Both Gmail backends use restricted scopes, so a public app needs Google's restricted-scope verification, which includes a yearly security assessment by a third-party assessor whose fee you negotiate yourself. Internal apps in your own Workspace avoid it, and send-only apps using gmail.send skip the assessment, though they still need Google's lighter sensitive-scope verification. Until verified, Google caps the app at 100 users.

Is EmailEngine open source?

No. The source code is public on GitHub, but EmailEngine runs under the EmailEngine License Agreement from Postal Systems OÜ, a proprietary license under Estonian law. You can run it free for a 14-day trial, after which syncing, sending and webhooks stop until a license key is added, while the API and data in Redis remain. GitHub issues are disabled on the repository, so support goes through the vendor.

How many mailboxes can one EmailEngine instance handle?

Several thousand, according to EmailEngine's performance guide, with Redis sized at 1 to 2 MiB per account and provisioned twice over. It cannot scale out: you must run exactly one replica per Redis database. Beyond one instance, you shard accounts across instances, each with its own Redis, and your application routes each request to the right one. With reconnection pacing set to 3 seconds, a restart takes about 50 minutes to bring back 1,000 accounts.

How does EmailEngine differ from Nylas?

EmailEngine is software you host for a flat yearly fee, and it reads mail live from the provider without storing it. Nylas is a managed API priced per connected account, which stores mailbox data on its platform in a US or European region, adds calendar and meeting products, and removes the hosting work. On monthly prices, Nylas is cheaper below about 61 mailboxes. Our Nylas alternatives guide compares the managed options.

Ship email and LinkedIn outreach without building the engine

Campaigns, mailbox pools, per-mailbox caps, bounce suppression and reply webhooks on email, plus LinkedIn steps in the same sequence.

Cold email from $59 a month for 125,000 sends; LinkedIn from $16.90 per sender a month, tiered down to $6.90.

Alexandre Risser

Written by

Alexandre Risser

Swarmhit

Building Swarmhit. Writes about LinkedIn outreach, multi-sender infrastructure, and outbound that books meetings.

Ready to ship cold email in your product?

Campaigns across mailbox pools, per-mailbox caps and pacing, threaded follow-ups and bounce handling, behind one API. From $59 a month for 125,000 sends, with unlimited mailboxes.

Keep reading