An ImprovMX alternative for code that has to read the mail
ImprovMX forwards mail on your domain to a mailbox a person reads. If the reader is your application, you need the message as data — here is the difference.
ImprovMX’s documentation and pricing last read 30 July 2026
The short version
- ImprovMX forwards mail to a mailbox. Inboundr parses it, stores it and hands it to your code — those are different products, not better and worse ones.
- If a person reads the mail, ImprovMX is cheaper and simpler, and this page will happily send you there.
- If an application or an agent reads the mail, the work you avoid is an IMAP poller, a MIME parser, attachment storage and a retry queue.
- Migration is two DNS records and can run alongside your existing forwarding until you are convinced.
What ImprovMX is for
ImprovMXis an email forwarding service. You point your domain’s MX record at it, define aliases like hello@yourdomain.com, and mail sent to those aliases is forwarded to a mailbox you already read — Gmail, Fastmail, whatever you use. Paid plans add SMTP credentials so you can send replies that appear to come from the alias rather than from your personal address.
For that job it is a good product, and it is worth saying so plainly on a page like this one: it is inexpensive, it has been doing the same thing for years, and there is very little to configure. Thousands of small businesses run their entire mail identity on it.
The reason people end up searching for an alternative is not that it forwards badly. It is that at some point the reader of the mail stops being a person.
Where forwarding stops being enough
A forwarding service’s contract is: a message arrives, a copy leaves. It is not holding onto the message, it has not taken it apart, and it has no opinion about what was in it. That is exactly right when the destination is a human inbox, and exactly wrong when the destination is code.
The wall usually shows up as one of these:
- You are parsing MIME in your own codebase. To act on the mail you forwarded, something has to log into the destination mailbox over IMAP, work out which messages are new, and decode multipart bodies and quoted-printable text. That is a stateful poller and a MIME parser, and both are now yours.
- Support tickets arrive as forwarded email. You wanted
POST /ticketswith a JSON body. What you have is a mailbox, and the gap between the two is a service you did not plan to write. - An agent needs to read and answer mail. An LLM given IMAP credentials and a raw RFC 5322 message spends most of its context on envelope headers and quoted history before it gets to the sentence that matters.
- You need to know why a message never arrived. Forwarding is fire and forget by design. Once the copy has left, spam verdicts, SPF and DKIM results and the reason a downstream provider rejected it are not yours to query.
This is not a criticism of the product
Nothing above is a bug. A forwarder that stored, parsed and indexed your mail would be a different product with a different privacy posture and a different price. The question is only which of the two you need.
Side by side
Read the ImprovMXcolumn as the answer to “can my code do this without me building something first”, not as a scorecard. Where it says partly, the capability exists but not in the shape an application wants.
| What you need | Inboundr | ImprovMX |
|---|---|---|
| Receive mail on a domain you own | Verify the domain, point one MX record and a DKIM record at us, and every address on it resolves — including a catch-all. | The same MX-record setup, and the thing the product was built to do. Aliases and a catch-all are configured per domain. |
| Forward to a mailbox a person reads | A forwarding endpoint re-sends the original message, headers intact, to one address or a group of them. | The core feature, and it is well worn — years of production traffic behind it. |
| The parsed message delivered to your app | An HMAC-signed email.received webhook per message: subject, text and HTML bodies, addresses, threading ids, attachment metadata, spam and SPF/DKIM verdicts. | There is no webhook that posts you a parsed message. Mail leaves as mail, to a mailbox — if your code needs the body, it reads it back over IMAP from wherever the mail landed. |
| An API that returns the messages themselves | REST endpoints list and fetch stored messages and threads, so a job that ran while your service was down can catch up afterwards. | The API manages domains, aliases and SMTP credentials, and exposes delivery logs. It is an administration API, not a way to read the mail. |
| Attachments your code can fetch | Each attachment is stored separately and handed out as a short-lived download link, so the webhook body stays small. | Attachments ride along with the forwarded message, subject to a per-message size limit. Getting one into your application means pulling it out of the destination mailbox. |
| Send a threaded reply from code | Name the message you are answering and the threading headers are written for you, so the reply lands in the same conversation rather than starting a new one. | Paid plans include SMTP credentials for sending as your alias. Threading is yours to construct: you set the headers, in your own client. |
| An AI agent that can work its own inbox | A hosted MCP server on the same API key. An agent lists, reads and replies to mail as tool calls, with no glue code in between. | No MCP server and no agent-facing interface. It was designed for a person at a mailbox, which is a reasonable thing to have designed for. |
| Filtering before delivery | Rules match on sender, recipient, subject or spam verdict and drop or route the message before it reaches your endpoint. | Spam filtering happens on the way through, but the decision is not exposed to you as data, and rules of your own belong in the destination mailbox. |
Receive mail on a domain you own
- Inboundr
- Verify the domain, point one MX record and a DKIM record at us, and every address on it resolves — including a catch-all.
- ImprovMX
- The same MX-record setup, and the thing the product was built to do. Aliases and a catch-all are configured per domain.
Forward to a mailbox a person reads
- Inboundr
- A forwarding endpoint re-sends the original message, headers intact, to one address or a group of them.
- ImprovMX
- The core feature, and it is well worn — years of production traffic behind it.
The parsed message delivered to your app
- Inboundr
- An HMAC-signed email.received webhook per message: subject, text and HTML bodies, addresses, threading ids, attachment metadata, spam and SPF/DKIM verdicts.
- ImprovMX
- There is no webhook that posts you a parsed message. Mail leaves as mail, to a mailbox — if your code needs the body, it reads it back over IMAP from wherever the mail landed.
An API that returns the messages themselves
- Inboundr
- REST endpoints list and fetch stored messages and threads, so a job that ran while your service was down can catch up afterwards.
- ImprovMX
- The API manages domains, aliases and SMTP credentials, and exposes delivery logs. It is an administration API, not a way to read the mail.
Attachments your code can fetch
- Inboundr
- Each attachment is stored separately and handed out as a short-lived download link, so the webhook body stays small.
- ImprovMX
- Attachments ride along with the forwarded message, subject to a per-message size limit. Getting one into your application means pulling it out of the destination mailbox.
Send a threaded reply from code
- Inboundr
- Name the message you are answering and the threading headers are written for you, so the reply lands in the same conversation rather than starting a new one.
- ImprovMX
- Paid plans include SMTP credentials for sending as your alias. Threading is yours to construct: you set the headers, in your own client.
An AI agent that can work its own inbox
- Inboundr
- A hosted MCP server on the same API key. An agent lists, reads and replies to mail as tool calls, with no glue code in between.
- ImprovMX
- No MCP server and no agent-facing interface. It was designed for a person at a mailbox, which is a reasonable thing to have designed for.
Filtering before delivery
- Inboundr
- Rules match on sender, recipient, subject or spam verdict and drop or route the message before it reaches your endpoint.
- ImprovMX
- Spam filtering happens on the way through, but the decision is not exposed to you as data, and rules of your own belong in the destination mailbox.
When ImprovMX is the better choice
- A person is the reader, and always will be. If what you want is
hello@landing in Gmail so it looks professional on a business card, you do not need parsed bodies, storage or an API, and you should not pay for them. - You want as few moving parts as possible. Aliases plus a destination address is a complete mental model that fits in one screen. Domains, addresses, endpoints and rules is a richer model, and richer is not free.
- You would rather nobody stored your mail. A forwarder holds a message for as long as it takes to pass it on. We store it for 15 days, on every plan, because an API that can re-deliver a message has to have kept it. If minimising that is the priority, forwarding wins on principle.
- Years of the same job. ImprovMX has been forwarding mail far longer than we have existed. On a pure forwarding workload that track record is a real argument, and we are not going to pretend otherwise.
What the message looks like as data
The concrete difference is one HTTP request. Instead of a copy of the mail arriving in a mailbox, your endpoint is called with the message already taken apart:
{
"event": "email.received",
"email": {
"id": "em_2f9c1a4b7d3e5601",
"threadId": "thr_8b21c0f4a95d",
"messageId": "<CAF9xq2@mail.example.com>",
"from": "customer@example.com",
"to": ["support@yourdomain.com"],
"cc": [],
"subject": "Invoice 4021 looks wrong",
"text": "Hi — line 3 is billed twice…",
"html": "<p>Hi — line 3 is billed twice…</p>",
"attachments": [
{ "filename": "invoice-4021.pdf",
"contentType": "application/pdf",
"size": 84213 }
],
"verdicts": { "spam": "PASS", "spf": "PASS", "dkim": "PASS" },
"receivedAt": "2026-07-30T09:14:22.104Z"
}
}Three headers come with it: x-inboundr-event, x-inboundr-delivery-id for idempotency, and x-inboundr-signature, an HMAC over the body and a timestamp so your handler can prove the request came from us. Failed deliveries are retried with backoff, and the message stays fetchable over the REST API for its retention window, so an outage on your side is not a lost email.
If the reader is an agent rather than a handler, the same account also answers over the Model Context Protocol, and no webhook is involved at all:
# One endpoint, the same API key.
https://inboundr.net/api/mcp
Some of the tools the agent gets:
list_emails newest first; filter by address, thread or direction
get_email full bodies, attachment metadata, auth verdicts
get_thread the whole conversation, oldest first
send_email pass inReplyTo to answer inside the threadThat is the part no forwarding service can offer, because it requires having kept and parsed the message in the first place. See the MCP tools for the full list, or how to give an agent its own address for what to do with them.
What each one costs
Deliberately no price table here. Both products change their pricing and a stale figure on a comparison page is worse than none, so check theirs at the source and ours here.
What is worth knowing is the shape of each bill:
- ImprovMX prices per domain, with a free tier that forwards for one domain and paid tiers that add SMTP sending, more domains and higher limits. Volume is bounded by fair-use limits rather than metered.
- Inboundr prices per account with an included message allowance, then meters what you use beyond it. Domains are not the billable unit — messages are — so twenty domains on one account is not twenty subscriptions.
For a single domain forwarding a modest amount of mail to a person, forwarding is the cheaper answer and probably always will be. The comparison only tips when you would otherwise be paying an engineer to build the parsing, storage and retry layer that turns forwarded mail into something a program can use.
Moving a domain across
The cutover is a DNS change, and it can be done without a gap in coverage if you do it in this order:
- Add the domain in the Inboundr console and copy the two records it shows you — one MX record and one DKIM record. Do not change your DNS yet.
- Create the endpoint that will receive the mail. If you are replacing forwarding like for like, that is a forwarding endpoint pointed at the same mailbox; if this is the migration that motivated the move, it is a webhook.
- Publish the DKIM record and wait for the domain to verify. This step touches nothing about delivery, so it is safe to do while ImprovMX is still live.
- Replace the MX record. Mail already in flight follows the old record until resolvers pick up the change; a low TTL set an hour beforehand shortens that to minutes.
- Send yourself a test message and confirm it arrives at the endpoint. The console shows the parsed message and the delivery attempt, so a failure here is visible rather than silent.
- Leave the ImprovMX aliases in place for a few days. They cost nothing once the MX record no longer points at them, and they are your rollback.
One thing that does not migrate
Mail already delivered to your destination mailbox stays there. We only see messages that arrive after the MX change — there is no backfill, because there is nothing for us to read.
Questions people ask
Can I keep forwarding to Gmail as well as posting to my app?
Yes — an address can have more than one endpoint, so the same message can be forwarded to a person and posted to your webhook. That is also the low-risk way to migrate: add the webhook alongside the forward, watch it for a week, then decide whether the forward is still doing anything for you.
Do I have to move my DNS hosting?
No. You keep your registrar and your DNS provider and add two records. Neither product needs to host your zone — that is Cloudflare Email Routing’s constraint, not this one.
Is ImprovMX's API not enough to build on?
It depends what you are building. For provisioning — creating domains and aliases from your own admin panel — it is a perfectly good API and does what it says. What it does not do is return the contents of messages, because the service does not keep them. If your program needs the body of the mail, the API is not the missing piece; storage is.
What happens to mail if my webhook is down?
The delivery is retried with exponential backoff, and the message stays in storage for your plan’s retention window, so you can re-fetch or re-deliver it after the fact. Compare with forwarding, where a rejection by the destination mailbox is between it and the sender.
Can I build this myself instead of either?
Yes, and for some teams that is the right answer — a cloud mail receiver wired to a function of your own is a weekend to something that works. Price in what comes after the weekend: a MIME parser that meets real mail from real clients, attachment storage, a retry path with somewhere to hold the message meanwhile, threading, and a bounce pipeline for the replies you send. Worth it when inbound mail is the product; expensive when it is one feature of it.
Claims about ImprovMX were checked against their public guides, API reference and pricing page. Read on 30 July 2026. If something here is out of date, tell us and we will correct it.