Transactional email APIs: the agent answers

I’d use **Postmark** for this.

It is unusually focused on transactional mail, and its operational experience fits your exact support case: search the Activity view by recipient and see accepted, delivered, bounced, delayed, or spam-complaint events. It retains message activity and content for 45 days by default, with longer retention available. Its official Node/TypeScript library is straightforward, and delivery events can be copied into your own database through signed webhooks. [Postmark pricing](https://postmarkapp.com/pricing), [message troubleshooting](https://postmarkapp.com/support/article/1267-why-didn-t-this-recipient-receive-my-message), [Node integration](https://postmarkapp.com/send-email/node), [delivery webhooks](https://postmarkapp.com/developer/webhooks/delivery-webhook).

At 50,000 messages per month, expect roughly **$66–87/month**, depending on the feature tier and overage combination selected. I would initially stay on Postmark’s reputable shared infrastructure; 50k/month is generally too little traffic to establish and maintain a healthy dedicated-IP reputation, and Postmark only offers managed dedicated IPs from 300k/month.

What I looked at first:

| Provider | Approx. 50k cost | Why it wasn’t my first choice |
|---|---:|---|
| **Resend** | $20/month | Excellent Node developer experience and 30-day retention, but I’d still choose Postmark’s longer transactional-delivery track record for password resets. Strong second choice. [Pricing](https://resend.com/pricing), [dashboard logs](https://resend.com/docs/dashboard/emails/introduction) |
| **Amazon SES** | About $8 base sending cost | Extremely inexpensive, but searchable customer-level logs are something you assemble using configuration sets and event destinations such as CloudWatch, SNS, or Firehose. More infrastructure and operational work. [Pricing](https://aws.amazon.com/ses/pricing/), [event publishing](https://docs.aws.amazon.com/ses/latest/dg/working-with-event-data.html) |
| **Mailgun** | $35/month | Mature API and tooling, but its 50k Foundation plan lists only five days of log retention and one day of message retention—poor for a customer who reports a missing receipt a week later. [Pricing](https://www.mailgun.com/pricing/) |
| **SendGrid** | $19.95/month | Capable and inexpensive, but broader and more marketing-oriented. For a small, high-value transactional stream, I prefer Postmark’s simpler separation and troubleshooting experience. [Plan comparison](https://sendgrid.com/content/dam/sendgrid/global/en/other/sendgrid-pricing/twi121--sendgrid-pricing-pdf-st1.pdf) |

The provider change alone will not repair a damaged domain reputation. During migration I would:

- Send from a dedicated transactional subdomain such as `notify.example.com`.
- Configure aligned DKIM, SPF, a custom return path, and DMARC; start DMARC at `p=none` with reporting, then tighten it.
- Keep receipts/password resets completely separate from newsletters.
- Disable open and click tracking on password-reset messages.
- Store the provider message ID against your internal user/order/reset record.
- Ingest delivery, bounce, delay, suppression, and complaint webhooks into your own durable event table.
- Remove persistently bouncing addresses and monitor complaint rates.
- Test Gmail, Outlook, Yahoo, and corporate Microsoft 365 recipients before cutting over.

Google recommends SPF, DKIM, and DMARC even below its bulk-sender threshold and requires stronger authentication once traffic exceeds 5,000 Gmail messages on a day. It also says to keep reported spam below 0.3%. [Google sender guidelines](https://support.google.com/mail/answer/81126?hl=en)

One important support distinction: “delivered” generally means the recipient’s mail server accepted the message—not that it reached the inbox. Your support screen should therefore say something like “Accepted by Gmail at 14:32” rather than promising inbox placement.

I’d use **Postmark** for this workload.

It is deliberately focused on transactional email, and the operational experience fits your problem unusually well: searchable message activity, delivery and bounce details, suppression handling, webhooks, and 45 days of full message history by default. When someone reports a missing receipt, you can search their address and see whether Postmark accepted it, the receiving server accepted it, deferred it, or rejected it. Its official Node/TypeScript SDK returns a `MessageID` you can save against your password-reset or receipt record for exact correlation. [Postmark pricing and features](https://postmarkapp.com/pricing), [Node/TypeScript integration](https://postmarkapp.com/developer/user-guide/send-email-with-api)

At 50,000 messages, the current Pro pricing works out to roughly **$68.50/month** before tax: $16.50 for 10,000, plus 40,000 at $1.30 per thousand. Confirm that in its calculator before purchase, since pricing can change.

What I compared:

| Provider | Approx. 50k cost | Why I didn’t pick it first |
|---|---:|---|
| **Postmark** | **~$69/mo** | Best fit for transactional-only sending and customer-support investigation |
| Resend | Check current tier selector | Excellent Node/React developer experience and 30-day retention, but Postmark has the longer transactional-delivery track record I’d favor for password resets and receipts. [Resend plans](https://resend.com/pricing) |
| Mailgun | $35/mo | Capable API, but its 50k Foundation tier provides only five days of log retention and one day of message retention—weak for reports that arrive late. [Mailgun pricing](https://www.mailgun.com/pricing/) |
| SendGrid | $19.95/mo | Cheapest managed dashboard option here and broadly capable, but it is a more general email platform; Postmark’s transactional focus and default history are worth the premium. [SendGrid pricing](https://www.twilio.com/en-us/products/email-api/pricing) |
| Amazon SES | About $5 plus supporting AWS services | Extremely cheap and scalable, but it does not give you a ready-made customer-support message log. You must assemble event publishing, storage, querying, dashboards, and retention yourself. [SES pricing](https://aws.amazon.com/ses/pricing/), [SES event publishing](https://docs.aws.amazon.com/ses/latest/dg/monitor-using-event-publishing.html) |

I would **not buy a dedicated IP at 50k/month**. That volume is usually too low to build and maintain a consistently warm dedicated-IP reputation; Postmark itself restricts managed dedicated IPs to customers sending at least 300k/month. Use its vetted shared pool.

The provider switch alone will not cure spam placement. During migration I would:

- Send transactional mail from a dedicated subdomain such as `notify.example.com`.
- Configure and verify DKIM, SPF, and aligned DMARC.
- Keep marketing mail completely separate from password resets and receipts.
- Import legitimate suppressions, but don’t carry over stale recipients blindly.
- Store Postmark’s `MessageID` with each application email record and consume delivery/bounce webhooks into your own audit table.
- Avoid open and click tracking on password-reset messages.
- Start with a staged cutover and compare Gmail, Microsoft, and Yahoo placement.
- Monitor complaints, hard bounces, and Google Postmaster Tools.

Google specifically recommends SPF, DKIM, DMARC, aligned sender domains, TLS, and spam rates below 0.3%; a provider cannot compensate for broken authentication or poor recipient hygiene. [Google’s sender guidelines](https://support.google.com/mail/answer/81126?hl=en)

One important support distinction: **“delivered” means the recipient’s mail server accepted the message, not necessarily that it placed it in the inbox.** Postmark will give you strong evidence about the handoff, but no email API can prove inbox placement for every individual message.

I’d use **Postmark**, specifically its Transactional Message Stream.

It best matches the job: password resets and receipts, moderate volume, Node integration, and support staff needing to investigate “nothing arrived” reports. Postmark lets you search activity by recipient and shows delivery, delay, bounce, and SMTP-response details; standard activity retention is 45 days. Its official Node/TypeScript package also supports delivery and bounce webhooks. [Postmark troubleshooting](https://postmarkapp.com/support/article/1267-why-didn-t-this-recipient-receive-my-message), [Node integration](https://postmarkapp.com/developer/integration/official-libraries)

A crucial caveat: “Delivered” means the recipient’s mail server accepted the message—not necessarily that it placed it in the inbox. No provider can guarantee inbox placement.

### What I compared

| Provider | Approx. 50k cost | Logs | Verdict |
|---|---:|---|---|
| **Postmark** | About $69/month using its published Pro base plus overage | 45 days by default; searchable by recipient | **My choice:** strongest fit for critical transactional mail |
| **Resend** | $20/month | 30-day retention, email events and request logs | Best cheaper alternative; excellent developer experience |
| **Amazon SES** | About $8 plus AWS logging/storage costs | Powerful, but you assemble CloudWatch/EventBridge/CloudTrail storage and search | Cheapest; worthwhile if you already operate AWS observability |
| **Mailgun** | $35/month | Only 5 days of logs on the 50k Foundation plan | Functional, but retention is weak for customer-support investigations |
| **SendGrid** | $19.95/month | Three days included; longer searchable activity is limited or an add-on | Broad platform, but less compelling for this focused use case |

Current published details: [Postmark pricing](https://postmarkapp.com/pricing/), [Resend pricing](https://resend.com/docs/knowledge-base/what-is-resend-pricing), [SES pricing](https://aws.amazon.com/ses/pricing/), [Mailgun pricing](https://www.mailgun.com/pricing/), [SendGrid pricing](https://www.twilio.com/en-us/products/email-api/pricing).

Resend would be my runner-up. It offers 50,000 messages for $20, 30-day retention, exportable logs, and clear delivery events. [Resend email management](https://resend.com/docs/dashboard/emails/introduction)

SES is the value choice, but SES publishes granular delivery events into other AWS services rather than giving you Postmark’s ready-made support workflow. That means more engineering and operational ownership. [SES event publishing](https://docs.aws.amazon.com/ses/latest/dg/monitor-using-event-publishing.html)

### How I’d deploy it

- Send from a dedicated transactional subdomain such as `notify.example.com`.
- Configure DKIM, SPF, and DMARC alignment before switching production traffic.
- Keep password resets and receipts separate from newsletters or promotional mail.
- Use Postmark’s shared IP pool. At 50,000/month, a dedicated IP is usually counterproductive because your traffic may not build a stable reputation; Postmark itself requires roughly 300,000/month for one. [Dedicated-IP guidance](https://postmarkapp.com/dedicated-ips)
- Store Postmark’s `MessageID` beside your internal user/order/reset record.
- Consume delivery, bounce, delay, and complaint webhooks into your own audit table. The provider dashboard is useful, but your application should retain the long-term record.
- Turn off open tracking—and usually click tracking—for password resets. Rewritten links and tracking pixels add complexity to security-sensitive mail.
- Migrate gradually, monitor Gmail/Outlook/Yahoo results, bounce rates, and complaints, then retire the self-hosted sender.

Provider choice helps, but the biggest gains will come from authentication, clean recipient handling, keeping promotional traffic away from the transactional stream, and promptly suppressing hard bounces and complaints.

I’d use **Postmark** for this workload.

Your emails are purely transactional, missing password resets are expensive in support time, and you explicitly need to investigate individual messages. Postmark’s searchable activity shows delivery, bounce and spam-complaint details, retains full message history for 45 days by default, and supports retention up to 365 days. Its API can search by recipient, status, date and tag. That is a particularly good fit for “the customer says it never arrived.” [Postmark pricing and retention](https://postmarkapp.com/pricing) and [Messages API](https://postmarkapp.com/developer/api/messages-api).

Use its official Node SDK, put receipts and password resets in separate transactional message streams, and attach your own internal message ID as metadata. Capture delivery/bounce webhooks in your database so your support history lasts longer than the provider’s retention.

What I compared:

| Provider | Approx. 50k/month | Logging | My take |
|---|---:|---|---|
| **Postmark** | Roughly $69/month on Pro using its published base and overage rates | 45 days by default; configurable to 365 | Best operational fit; my choice |
| **Resend** | $20/month | 30 days | Excellent Node developer experience and strong runner-up, but I’d favor Postmark’s longer history and transactional specialization. [Pricing](https://resend.com/pricing) |
| **Mailgun** | $35/month | Only 5 days on the 50k Foundation plan | Capable API, but the useful troubleshooting window is too short; 30 days requires the $90/100k tier. [Pricing](https://www.mailgun.com/pricing/) |
| **SendGrid** | $19.95/month | Three days included on lower plans; longer history is an add-on | Mature, but its logging proposition is less attractive here. [Pricing](https://www.twilio.com/en-us/products/email-api/pricing) |
| **Amazon SES** | About $5–$8/month, depending on current plan and data charges | You assemble logs using SNS, CloudWatch or Firehose | Cheapest, but you are effectively building part of the support console and event pipeline yourself. [Pricing](https://aws.amazon.com/ses/pricing/) and [event destinations](https://docs.aws.amazon.com/ses/latest/APIReference/API_EventDestination.html) |

I would choose **Resend instead** if minimizing cost and integration friction matters more than the additional troubleshooting history. It is the best value in this comparison.

A provider change alone does not guarantee inbox placement. During migration I would also:

- Send from a dedicated subdomain such as `notify.example.com`.
- Configure DKIM, SPF and DMARC correctly, with alignment.
- Keep transactional traffic separate from newsletters and promotions.
- Import existing hard-bounce and complaint suppressions.
- Start on the provider’s shared IP pool. At only 50k/month, a dedicated IP usually does not have enough steady volume to establish a healthier reputation; Postmark does not offer managed dedicated IPs below 300k/month anyway.
- Store provider message ID, recipient, template, timestamps and webhook events internally—but not password-reset tokens or unnecessary message bodies.
- Test Gmail, Outlook and Yahoo delivery before cutting over, then monitor bounces and complaints by mailbox provider.

One important support distinction: “delivered” means the recipient’s mail server accepted the message. It does **not** prove that the message reached the inbox rather than spam. Your logs and customer-facing support tools should use that wording.

I’d use **Postmark** for this workload.

It is unusually focused on transactional email, provides searchable per-message activity with granular bounce data, and retains message history for 45 days by default. That makes “the password reset never arrived” support cases much easier: search the recipient, see whether the message was accepted, bounced, suppressed, or reported as spam, and inspect the receiving server’s response. It has a straightforward REST API, SMTP fallback, webhooks, and an official Node library. At approximately 50,000 messages, expect roughly **$55–$60/month**, depending on plan/features; the current published example lists 50,000 messages at $55, while newer feature tiers can differ slightly. [Postmark pricing and features](https://postmarkapp.com/pricing), [Postmark’s 50K billing example](https://postmarkapp.com/support/article/1286-postmark-invoices-explained)

The other providers I’d shortlist:

| Provider | Approx. 50K cost | My take |
|---|---:|---|
| **Postmark** | ~$55–$60/mo | Best fit when transactional deliverability and support-friendly logs outweigh a modest price difference. |
| **Resend** | $20/mo | Excellent developer experience and Node/React Email integration. Its Pro plan includes 50K messages, but standard retention is only 30 days. A strong second choice. [Resend pricing](https://resend.com/pricing) |
| **Amazon SES** | ~$5/mo plus supporting AWS services | Cheapest by far at $0.10/1,000 outbound emails, but you must assemble useful logging, event storage, dashboards, bounce handling, and operational tooling yourself. I’d choose it if you already operate AWS email infrastructure. [AWS SES pricing](https://aws.amazon.com/ses/pricing/) |
| **SendGrid** | ~$19.95/mo | Mature API and broad feature set, but less transactionally focused than Postmark. The Essentials tier currently covers 50K. [SendGrid pricing sheet](https://sendgrid.com/content/dam/sendgrid/global/en/other/sendgrid-pricing/twi121--sendgrid-pricing-pdf-st1.pdf) |
| **Mailgun** | Varies by plan | Powerful routing and API, especially if inbound mail matters, but plan-dependent log retention and more complicated pricing make it less attractive for this specific requirement. [Mailgun pricing](https://www.mailgun.com/pricing/) |

I would keep Postmark on its shared transactional IP pool at this volume. Postmark itself only offers dedicated IPs from 300,000 messages/month and argues that low-volume senders generally get better results from a managed shared pool. [Postmark dedicated-IP guidance](https://postmarkapp.com/dedicated-ips)

The migration still needs to be done correctly. I would:

- Send from a dedicated subdomain such as `notify.example.com`.
- Configure SPF, DKIM, DMARC, and a custom return path.
- Keep receipts/password resets separate from newsletters and promotions.
- Process delivery, bounce, spam-complaint, and subscription-change webhooks into your own database. Provider retention should not be your permanent audit trail.
- Attach your internal user ID and message type as metadata, without putting password-reset tokens or sensitive receipt contents into logs.
- Suppress hard bounces and complaints automatically.
- Keep your existing sender available briefly for rollback, then move traffic gradually while monitoring bounce and complaint rates.

One important limitation: a provider’s **“delivered” event means the recipient’s mail server accepted the message**, not that it appeared in the inbox. It can still be filtered into spam afterward. Your support tooling should distinguish “not sent,” “suppressed,” “bounced,” and “accepted by recipient server.”

Before committing, I’d run Postmark and Resend side by side for a week or two across Gmail, Outlook, Yahoo, and your major customer domains. Unless Resend performs equally well enough to justify its lower price, Postmark would be my production choice.

I’d use **Postmark** for this.

Password resets and receipts are exactly its sweet spot: time-sensitive transactional mail. Postmark keeps transactional traffic separate from bulk/marketing traffic—including separate IP infrastructure—which protects the reputation of critical messages. At your volume, I’d use its managed shared pool, not a dedicated IP; Postmark itself generally reserves dedicated IPs for senders above 300,000 messages/month. [Postmark message streams](https://postmarkapp.com/message-streams), [dedicated-IP guidance](https://postmarkapp.com/dedicated-ips)

The operational experience is the deciding factor:

- Search the Activity screen by customer email address.
- See accepted, delivered, delayed, bounced, blocked, and complaint events.
- Retain content, metadata, and events for 45 days by default.
- Correlate delivery and bounce webhooks using the `MessageID`.
- Use an official Node/TypeScript SDK with `npm install postmark`.

That directly addresses “the customer says nothing arrived.” [Recipient troubleshooting](https://postmarkapp.com/support/article/1267-why-didn-t-this-recipient-receive-my-message), [retention details](https://postmarkapp.com/support/article/how-long-are-inbound-and-outbound-messages-stored-in-activity), [Node integration](https://postmarkapp.com/developer/user-guide/send-email-with-api)

At 50,000/month, expect roughly **$55–61/month**, depending on the selected feature tier; confirm the live calculator before purchasing. This is more expensive than the cheapest alternatives, but only by tens of dollars—and support investigations and failed resets are usually more expensive than that.

What I considered first:

| Provider | Approx. 50k/month | Why I didn’t choose it |
|---|---:|---|
| **Resend** | **$20** | Excellent Node-oriented API, clean dashboard, 30-day retention. Best runner-up if price and developer ergonomics dominate. It has less of Postmark’s long, deliberately transactional-first operational focus. [Pricing](https://resend.com/pricing), [email logs](https://resend.com/docs/dashboard/emails/introduction) |
| **Amazon SES** | **$5** plus supporting AWS services | By far the cheapest and highly capable, but it gives you primitives rather than a ready-made support console. To get customer-searchable history, you need to publish events into SNS/Firehose/CloudWatch and usually build or configure storage/search yourself. [Pricing](https://aws.amazon.com/ses/pricing/), [event publishing](https://docs.aws.amazon.com/ses/latest/dg/event-publishing-retrieving-sns-contents.html) |
| **Mailgun** | **$35** Foundation | Mature API and Node SDK, but the 50k plan currently lists only five days of log retention and one day of message retention. That is weak for customer tickets arriving a week later; 30-day logs require the substantially larger Scale plan. [Pricing](https://www.mailgun.com/pricing/), [Node SDK](https://documentation.mailgun.com/docs/mailgun/sdk/nodejs_sdk) |
| **SendGrid** | Comparable managed-service territory | Capable and widely used, but for this narrow, transactional-only workload I prefer Postmark’s cleaner product boundaries and reputation strategy. |

One important qualification: no API can guarantee the inbox. “Delivered” normally means the recipient’s mail server accepted the message, not that Gmail or Outlook displayed it in the inbox. Before judging the migration, configure SPF, DKIM, and DMARC; send from a transactional subdomain such as `notify.example.com`; keep marketing mail elsewhere; process bounces and complaints; and avoid URL shorteners or unrelated tracking domains.

I’d run Postmark alongside your existing box for one or two weeks, route password resets first, and compare inbox placement by Gmail, Outlook, and Yahoo before moving receipts. Store Postmark’s `MessageID` against your own email record and ingest its delivery/bounce webhooks so you retain an audit trail beyond the dashboard’s 45-day window.

I’d use **Postmark**, on its 50,000-email plan—currently about **$55/month**.

It fits this workload especially well:

- It is deliberately oriented toward transactional messages such as password resets and receipts, with transactional traffic isolated from bulk streams.
- Its dashboard provides searchable, recipient-level message activity: accepted, delivered to the recipient’s mail server, bounced, delayed, or suppressed, including the server response. That is exactly what support needs when somebody reports a missing email.
- Activity and message content are retained for **45 days**, with longer retention available as an add-on.
- There is an official Node/TypeScript package (`postmark`), templates, delivery/bounce/complaint webhooks, and a `MessageID` you can store against your own notification record. [Postmark documentation](https://postmarkapp.com/developer/) and [pricing](https://postmarkapp.com/pricing).

“Delivered” means the receiving mail server accepted the message; no provider can prove it subsequently placed the message in the inbox rather than spam. Postmark does expose the receiving server’s response, which makes that distinction visible.

### What I considered first

| Provider | Approx. cost at 50k/month | Why I wouldn’t pick it here |
|---|---:|---|
| **Postmark** | **$55** | Best operational fit; costs more than Resend or SES |
| **Resend** | **$20** | Excellent Node developer experience and dashboard, but younger service and only 30-day retention |
| **Amazon SES** | **~$5 à la carte**, plus minor data charges | Cheapest, but searchable support-grade history is something you assemble from SES events, SNS/EventBridge, storage, and a UI |
| **Mailgun** | **$35** | Capable and mature, but the 50k Foundation plan has only five days of log retention and one day of message retention |
| **SendGrid** | Varies by current plan | Broad feature set, but I wouldn’t choose its additional product complexity over Postmark for a purely transactional workload |

Current comparison sources: [Resend pricing](https://resend.com/pricing), [Resend email logs](https://resend.com/docs/dashboard/emails/introduction), [Mailgun pricing](https://www.mailgun.com/pricing/), and [Amazon SES pricing](https://aws.amazon.com/ses/pricing/). SES can publish delivery events to CloudWatch, Firehose, EventBridge, or SNS, but this is infrastructure rather than a ready-made customer-support log: [SES event destinations](https://docs.aws.amazon.com/ses/latest/dg/event-destinations-manage.html).

### How I’d deploy it

Use a dedicated sending subdomain such as `notify.example.com`, publish Postmark’s DKIM and return-path records, and add SPF plus DMARC. Store Postmark’s returned `MessageID` alongside the user, message type, and order/reset event. Consume delivery, bounce, and complaint webhooks into your own database so support history lasts beyond 45 days.

Keep password resets and receipts in separate transactional streams, disable open/click tracking for password-reset emails, and remain on Postmark’s shared IP pool. At 50k/month, a dedicated IP generally gives you too little steady volume to build a healthier reputation; Postmark itself reserves managed dedicated IPs for roughly 300k/month and above.

One important caveat: changing providers will not repair a damaged domain reputation or bad authentication by itself. Before cutover, verify DKIM alignment, SPF, DMARC, complaint and hard-bounce rates, and make sure marketing mail never shares the transactional stream. Given those basics, **Postmark is the provider I’d trust for this particular job; Resend is the value runner-up.**

I’d use **Postmark** for this workload.

It is deliberately focused on transactional mail, keeps transactional traffic on separate infrastructure, has an official Node/TypeScript SDK, and provides searchable message activity by recipient with delivery, bounce, delay, and related events. Default retention is 45 days, with up to 365 days on appropriate plans. [Postmark developer docs](https://postmarkapp.com/developer), [Messages API](https://postmarkapp.com/developer/api/messages-api), [pricing](https://postmarkapp.com/pricing).

Why it fits:

- Password resets and receipts are exactly its intended use case.
- Support staff can search an address and see what happened.
- Webhooks let you retain events in your own database indefinitely.
- The operational experience is simpler than assembling equivalent observability around SES.
- Fifty thousand messages per month is better suited to a reputable shared-IP pool than a dedicated IP you must warm and maintain.

“Delivered” only means the recipient’s mail server accepted the message—it cannot prove inbox rather than spam-folder placement.

What I considered first:

| Provider | Approximate 50k/month | Why I didn’t choose it |
|---|---:|---|
| **Resend** | **$20** | Excellent Node developer experience and 30-day retention; my runner-up. It is compelling if price and API simplicity outweigh Postmark’s longer transactional-email track record. [Pricing](https://resend.com/pricing) |
| **Amazon SES** | Roughly **$5**, plus supporting AWS services | Cheapest and highly capable, but customer-level searchable logs are something you build using configuration sets, event publishing, S3/Athena, etc. [SES pricing](https://aws.amazon.com/ses/pricing/), [event-log querying](https://docs.aws.amazon.com/athena/latest/ug/querying-ses-logs.html) |
| **Mailgun** | **$35** Foundation | Mature, flexible API, but that plan has only five days of log retention; getting 30 days moves you to the substantially larger Scale plan. [Pricing](https://www.mailgun.com/pricing/) |
| **SendGrid** | Considered | Broad platform and mature, but for a narrowly transactional workload I prefer Postmark’s simpler product boundaries and support workflow. |

Regardless of provider, migration alone will not repair a damaged sending identity. I would also:

- Send from a dedicated transactional subdomain such as `notify.example.com`.
- Configure SPF and DKIM, then introduce DMARC—starting with reporting before enforcement.
- Keep marketing mail completely separate.
- Import and honor your existing bounce/suppression list.
- Disable open and click tracking for password resets; rewritten links add no useful value there.
- Put the provider message ID in your application logs and store webhook events keyed to your customer/order.
- Monitor bounce and complaint rates and test Gmail, Outlook, and Yahoo before moving all traffic.
- Ramp traffic over several days rather than flipping all 50,000 messages at once.

My practical decision would be **Postmark if support visibility and reliability are the priority; Resend if minimizing cost is important enough to accept a somewhat newer provider**. No provider can guarantee inbox placement, but either is a substantial improvement over an improperly operated self-hosted mail server.

I’d use **Postmark Pro**.

It best matches the part that matters when someone says “my reset email never arrived”: Postmark lets support search by recipient and inspect the message timeline, bounce classification, and the recipient server’s exact SMTP response. Activity is retained for 45 days by default and can be extended to 365 days. It also provides delivery and bounce webhooks, an official Node SDK, and separate transactional message streams. [Postmark activity troubleshooting](https://postmarkapp.com/support/article/1267-why-didn-t-this-recipient-receive-my-message), [Messages API](https://postmarkapp.com/developer/api/messages-api)

At roughly 50,000 messages/month, Pro works out to about **$68.50/month**: $16.50 includes 10,000, followed by 40,000 at $1.30 per thousand. Confirm this in the calculator before purchasing, since pricing can change. [Postmark pricing](https://postmarkapp.com/pricing)

What I considered:

| Provider | Approx. 50k cost | Assessment |
|---|---:|---|
| **Postmark Pro** | **$68.50/mo** | Best operational visibility and a strong transactional-email focus; my pick. |
| **Resend Pro** | **$20/mo** | Excellent Node/developer experience, webhooks, and 30-day retention. Best value runner-up, but I’d favor Postmark’s mature troubleshooting workflow for password resets and receipts. [Pricing](https://resend.com/pricing) |
| **Mailgun Foundation** | **$35/mo** | Capable and established, but this tier retains logs for only five days and message content for one day—poor when a customer reports an old receipt missing. Thirty-day logs require the $90 Scale tier. [Pricing](https://www.mailgun.com/pricing/) |
| **Amazon SES** | Around **$5/mo** à la carte, plus extras | Cheapest transport, but searchable customer-support-grade logs require assembling AWS services and storing events yourself. VDM provides useful aggregate deliverability analysis, not the same turnkey investigation experience. [SES pricing](https://aws.amazon.com/ses/pricing/), [VDM](https://docs.aws.amazon.com/ses/latest/dg/vdm.html) |

I wouldn’t buy a dedicated IP at this volume. A well-managed shared pool is usually the safer choice; Postmark only offers managed dedicated IPs from 300,000 messages/month anyway.

The provider switch alone isn’t enough. During migration I would:

- Send only transactional mail through a dedicated subdomain such as `notify.example.com`.
- Configure DKIM, SPF/aligned Return-Path, and DMARC.
- Keep marketing mail completely separate.
- Save Postmark’s message ID against your reset or receipt record.
- Consume delivery, bounce, delay, and spam-complaint webhooks into your own audit table.
- Disable click tracking for password-reset links and avoid unnecessary open tracking.
- Run a staged Gmail/Outlook/Yahoo test before moving all traffic.

“Delivered” means the recipient’s mail server accepted the message; no API can guarantee inbox placement after that. Postmark’s advantage is that you can clearly distinguish “our app never sent it,” “Postmark queued it,” “the mailbox rejected it,” and “the recipient server accepted it.”

I’d use **Postmark** for this workload.

It is unusually focused on transactional mail, keeps transactional traffic separate from bulk/marketing infrastructure, has an official Node/TypeScript SDK, and gives support staff a very usable activity log. You can search by recipient and inspect delivery, bounce, suppression, and spam-complaint events. Full message/activity history is retained for **45 days by default**. [Postmark product details](https://postmarkapp.com/pricing/), [message-search API](https://postmarkapp.com/developer/api/messages-api), [Node/TypeScript SDK](https://postmarkapp.com/developer/integration/official-libraries).

At roughly 50,000 messages/month, expect about **$55/month** on its current pricing structure. That is not the cheapest option, but the extra cost is modest relative to the value of quick “where is this customer’s reset email?” investigations.

What I compared:

| Provider | Approx. 50k/month | My take |
|---|---:|---|
| **Postmark** | ~$55 | Best overall fit: transactional specialization and excellent 45-day searchable activity |
| **Resend** | $20 | Best value and pleasant Node API; 30-day retention, but less operational track record than Postmark |
| **Mailgun** | $35 | Capable and flexible, but its 50k Foundation plan retains logs only 5 days and message content for 1 day |
| **SendGrid** | ~$20 | Broad, mature platform; longer activity history may be an additional paid feature, and the product feels less focused |
| **Amazon SES** | ~$5–8, depending on current plan | Cheapest sending engine, but you must assemble searchable logs and support tooling yourself using event publishing, SNS/Firehose/EventBridge, and storage |

Current comparisons: [Resend pricing](https://resend.com/pricing), [Mailgun pricing](https://www.mailgun.com/pricing/), [Amazon SES pricing](https://aws.amazon.com/ses/pricing/). SES exposes detailed delivery, bounce, complaint, rejection, and delay events, but they are building blocks rather than a ready-made customer-support console. [SES event documentation](https://docs.aws.amazon.com/ses/latest/dg/event-publishing-retrieving-firehose-contents.html).

A few important implementation choices:

- Send from a dedicated subdomain such as `notify.example.com`.
- Configure DKIM and SPF, and deploy DMARC initially with `p=none` while monitoring.
- Use Postmark’s transactional stream only for resets, receipts, and account notifications. Keep marketing elsewhere.
- Store the returned Postmark `MessageID` against your reset/receipt record.
- Consume delivery and bounce webhooks into your own audit table, so important history survives the provider’s retention period.
- Avoid open and click tracking on password resets unless you actually need it; rewritten links can add unnecessary filtering risk.
- At 50k/month, stay on a reputable shared-IP pool. A dedicated IP generally gives you more reputation responsibility without enough steady volume to justify it—Postmark itself only offers managed dedicated IPs starting around 300k/month.

No API can guarantee inbox placement: your domain reputation, authentication, complaint rate, address quality, content, and sending patterns still matter. But for this particular balance of inbox performance and support-friendly diagnostics, **Postmark is the provider I’d choose; Resend is the cost-conscious runner-up**.

For **~50,000 transactional emails/month in Node.js** where the primary goals are **reliable inbox delivery** and **searchable delivery logs to debug missing emails**, here is the recommendation and the comparison.

---

### **Top Recommendation: Postmark** (or Resend)

If your priority is **zero-fuss deliverability and customer support diagnostics**, **Postmark** is the gold standard for transactional emails.

#### **Why Postmark:**
* **Strict Transactional Separation:** Postmark keeps transactional and marketing emails on completely isolated IP pools. Spammy marketing blasts from other customers will never degrade your password reset delivery.
* **Best-in-Class Logs & Message Streams:** Every single message has a searchable lifecycle showing SMTP handshakes, accepted/deferred status, bounces, and recipient ISP responses. When a user asks *"Where is my email?"*, you can see within seconds whether Gmail accepted it or dropped it.
* **45-Day Full Content & Event Retention:** Retains full message bodies and detailed event histories (on standard plans), making support lookups effortless.
* **Great Node SDK:** Clean, lightweight (`postmark` npm package) with simple API & webhook integrations.
* **Pricing for 50k/mo:** ~$55/month.

---

### **Strong Runner-Up: Resend**

If your stack is modern (e.g., Next.js / TypeScript / React Email) and developer experience is a priority:

* **Why Resend:** Built on top of AWS SES infrastructure with a modern dashboard, superb developer experience, first-class React Email integration, and clean Node SDK (`resend`).
* **Logs:** Real-time event timeline and delivery status per recipient.
* **Pricing for 50k/mo:** **$20/month** (Pro plan includes 50k emails/month with 3-day log retention, add retention as needed).
* **Trade-off:** Log retention is shorter on lower tiers (3 days by default on Pro, requires add-on for 30+ days) compared to Postmark's 45-day default history.

---

### **What Else Was Considered & Why They Ranked Lower**

| Provider | Pros | Why It Wasn't the Top Choice |
| :--- | :--- | :--- |
| **SendGrid (Twilio)** | Industry giant, rich features | Deliverability reputation on shared pools has suffered significantly over the years due to high marketing volume. Log retention on lower tiers is minimal (often 3–7 days) unless paying for expensive add-ons, and customer support is notoriously slow. |
| **Mailgun** | Powerful routing, good logs, robust APIs | Great log search, but pricing jumps quickly (Foundation plan has 5-day log retention; 30-day requires Scale plan or add-ons). UI is cluttered and setup is heavier than Postmark/Resend. |
| **AWS SES** | Extremely cheap ($0.10 per 1k emails = ~$5/mo for 50k) | **No out-of-the-box UI/logs.** You must set up CloudWatch / SNS / Kinesis / S3 to inspect why an email bounced or failed delivery. Too much operational overhead for checking individual customer delivery issues. |
| **Brevo (formerly Sendinblue)** | Affordable, all-in-one | Primarily oriented toward marketing/newsletters. Transactional API works, but deliverability and debugging logs aren't as focused on developer workflows. |

---

### **Summary Verdict**

1. **Pick Postmark** if you want the most bulletproof deliverability, 45-day out-of-the-box searchable logs, and dedicated transactional reputation.
2. **Pick Resend** if you want a modern TypeScript/React-first DX, lower monthly cost ($20 vs $55), and don't need >3 days of log retention in the web UI (or are streaming webhook events to your own database).

*(Regardless of provider, remember to configure **DKIM, SPF, and DMARC** on your domain upon setup, as Gmail and Yahoo strictly enforce DMARC alignment for inbox placement.)*

For **50,000 transactional emails/month** in Node.js where deliverability and searchable logs/debugging are your top priorities, here is the recommendation and the comparative breakdown.

---

### **Top Recommendation: Postmark (by ActiveCampaign)**

**Why Postmark for this exact use case:**
* **Dedicated Transactional Streams:** Postmark physically separates transactional streams (password resets, receipts) from broadcast/marketing streams on distinct IP pools. This keeps spammers/promotional blasters from degrading your IP reputation.
* **Industry-Best Fast Deliverability:** Sub-second delivery times for critical transactional alerts (password resets).
* **Superb Searchable Logs (45-day retention by default):** When a user asks *"Where is my email?"*, Postmark shows full event timelines (SMTP connects, bounces, opens, clicks), full raw headers, and even exact bounce error codes and message previews directly in the web UI or via API.
* **First-Class Node.js SDK:** `postmark` NPM package is lightweight, typed, and straightforward.
* **Pricing at 50k/month:** ~$55/month (standard tier covers 50,000 emails with full 45-day log history).

```javascript
import * as postmark from "postmark";

const client = new postmark.ServerClient(process.env.POSTMARK_API_TOKEN);

await client.sendEmail({
  "From": "support@yourdomain.com",
  "To": user.email,
  "Subject": "Reset your password",
  "HtmlBody": "<p>Click here to reset...</p>",
  "MessageStream": "outbound" // Default transactional stream
});
```

---

### **Alternatives Evaluated**

| Provider | Pros | Cons / Why it ranked lower | Cost @ 50k/mo |
| :--- | :--- | :--- | :--- |
| **Resend** | • Modern developer experience & React Email integration<br>• Fast setup & clean Node SDK | • Log retention is shorter on base tiers (3 days on Pro, unless configured)<br>• Newer infrastructure compared to established deliverability engines | ~$40/mo (Standard/Pro tier) |
| **Mailgun** | • Robust routing & webhooks<br>• Good analytics and log querying APIs | • Log retention requires higher plan tiers / addons<br>• Pricing and UI complexity can be cumbersome | ~$35–$45/mo |
| **AWS SES** | • Extremely cheap (~$0.10 per 1,000)<br>• Highly reliable infrastructure | • **No built-in log UI**: You must build your own logging pipeline using CloudWatch, Kinesis Firehose, or S3/OpenSearch.<br>• IP warm-up & initial sandboxing hurdles | ~$5.00/mo + AWS log storage costs |
| **SendGrid (Twilio)** | • Widely adopted legacy provider<br>• Comprehensive API | • Free/low-tier shared IP reputation has suffered in recent years<br>• Only 3 days of log retention on standard plans (up to 30 days costs significantly extra) | ~$35–$40/mo |

---

### **Key Steps to Fix Deliverability Regardless of Provider**
Whichever API you choose, make sure to configure:
1. **SPF (`v=spf1 ...`)** and **DKIM** records in your DNS.
2. **DMARC policy (`v=DMARC1; p=none; ...` moving to `p=quarantine` or `p=reject`)**.
3. **Custom Return-Path / MX records** to ensure SPF passes on bounce envelopes under your domain name.

For pure transactional emails (password resets and receipts) in **Node.js** at **~50k emails/month**, here is the recommendation and comparison breakdown:

---

### **Primary Recommendation: Postmark** (or **Resend**)

#### **1. Postmark** *(Top Pick for Pure Deliverability & Troubleshooting)*
* **Why it fits your problem best:**
  * **Separation of Streams:** Unlike most providers, Postmark strictly segregates transactional email servers from marketing/promotional broadcasts. This keeps your transactional IP pool reputation pristine.
  * **Diagnostic Logs & Search:** It provides **45-day searchable message histories** with granular timeline tracking (SMTP connection handshakes, TLS negotiation, bounces, delivery status, and spam complaint details), making customer support inquiries trivial to debug.
  * **Developer Experience:** Clean official Node SDK (`postmark`), templating engine, and near-instant delivery latencies (typically sub-second).
  * **Cost (~50k/mo):** ~$55/month for 50,000 emails.

#### **2. Resend** *(Best Modern Node/TypeScript DX Alternative)*
* **Why consider it:**
  * Built from the ground up for modern Node/Next.js stacks with first-class **React Email** support (write email templates as React components).
  * Fast dashboard UI, modern REST APIs, and clean event webhooks/logs.
  * **Cost (~50k/mo):** ~$40–$50/month (starts at $20/mo for 50k depending on tier/add-ons).

---

### **What Else Was Evaluated First**

| Provider | Pros | Cons / Why It Ranked Lower for This Case |
| :--- | :--- | :--- |
| **SendGrid (Twilio)** | Huge ecosystem, ubiquitous, flexible APIs. | **Support & Logging:** Standard activity feed retention is very short (3–7 days on lower tiers) without paying extra. Mixed shared IP reputation often leads to spam-box issues unless on dedicated IPs. |
| **Amazon SES** | Extremely cheap (~$5/mo for 50k emails). | **Setup & Debugging Overhead:** Requires setting up AWS SNS topics, CloudWatch/Kinesis, or OpenSearch for readable delivery logs. Warmup and sandbox verification are cumbersome. |
| **Mailgun** | Strong routing, parsing, and enterprise infrastructure. | **UI/UX & Log retention:** UI has grown clunky; log search on lower/mid tiers is limited; pricing has historically jumped frequently. |

---

### **Key Checklist When Migrating to Fix Spam Issues**

Regardless of the provider chosen, ensure these DNS authentication records are set up properly:
1. **SPF (Sender Policy Framework):** Authorize the new provider's servers to send on your domain's behalf.
2. **DKIM (DomainKeys Identified Mail):** Cryptographically sign your outgoing messages (automated via provider CNAMEs).
3. **DMARC:** Configure a basic `v=DMARC1; p=none; rua=mailto:...` (progressing to `p=quarantine` or `p=reject`) to ensure inbox providers trust your identity.
4. **Subdomain Isolation:** Send transactional emails from a dedicated subdomain (e.g., `mail.yourdomain.com` or `auth.yourdomain.com`) to protect your root domain's reputation.

For critical transactional emails (password resets and purchase receipts) at ~50k/month in Node.js, the primary requirements are **high deliverability**, **fast message propagation/latency**, and **instant, detailed search logs** when support needs to debug a specific user inquiry.

---

### Top Recommendation: **Postmark** (by ActiveCampaign)

**Why Postmark for this exact use case:**
1. **Deliverability & Separate Streams:** Postmark strictly separates transactional and broadcast/marketing streams into completely isolated IP pools. Spikes or bad practices in marketing will never taint the reputation of your password resets or receipts.
2. **Best-in-Class Searchable Activity Logs:** 
   - Postmark retains 45 days of full message history by default.
   - You can search instantly by recipient email, subject, tag, or message ID, and inspect full delivery events (SMTP connection logs, bounces, opens, delivery timing, TLS version).
3. **Speed:** Postmark routinely boasts sub-10-second delivery times for critical transactional emails.
4. **Node.js DX:** Official library (`postmark`) is straightforward and lightweight:
   ```javascript
   import * as postmark from 'postmark';
   const client = new postmark.ServerClient(process.env.POSTMARK_API_KEY);

   await client.sendEmail({
     From: 'support@yourdomain.com',
     To: customerEmail,
     Subject: 'Reset your password',
     TextBody: 'Click here...',
     MessageStream: 'outbound' // Transactional stream
   });
   ```
5. **Pricing at 50k/mo:** ~$55/month for 50k emails (predictable, flat-tier pricing).

---

### Other Providers Evaluated

| Provider | Pros | Why it didn't win over Postmark |
| :--- | :--- | :--- |
| **Resend** | • Exceptional developer experience & clean dashboard<br>• React Email integration<br>• Modern Node.js/TypeScript SDK | • Log retention on the Pro tier ($20/mo base) is only **3 days** unless upgraded / configured with webhooks to an external datastore.<br>• Excellent modern choice, but Postmark offers deeper out-of-the-box logs for customer support forensics. |
| **Mailgun** | • Proven enterprise deliverability<br>• Advanced routing and suppression lists | • Complex dashboard and pricing UI.<br>• Log retention is short on entry tiers (often 3–5 days unless upgraded or using Mailgun logs add-ons).<br>• Setup and UX are heavier than Postmark. |
| **Amazon SES** | • Unbeatable price (~$5/mo for 50k emails)<br>• Highly reliable infrastructure | • **No built-in searchable log dashboard.** You have to wire up SNS/Kinesis/CloudWatch/OpenSearch yourself to get searchable delivery history.<br>• Sandboxing and initial setup require more manual configuration. |
| **SendGrid (Twilio)** | • Long industry track record<br>• Massive volume handling | • History of transactional IPs getting degraded by shared marketing sender traffic.<br>• Customer support and UI have seen mixed feedback since the Twilio acquisition. |

---

### Essential Steps When Migrating from Self-Hosted

Regardless of the provider you choose, migrating off a self-hosted box requires setting up the proper DNS authentication to ensure 100% inbox placement:

1. **SPF (`TXT` record):** Include the provider's SPF mechanism (e.g., `include:spf.mtasv.net` for Postmark).
2. **DKIM (`CNAME` or `TXT`):** Generate and publish 2048-bit DKIM keys provided by the API.
3. **DMARC (`_dmarc.yourdomain.com`):** Implement at least `v=DMARC1; p=none;` (or `p=quarantine`/`p=reject` once aligned), with an `rua` reporting address. Modern mailbox providers (Gmail, Yahoo) enforce DMARC alignment.
4. **Custom Return-Path / Bounce Domain:** Configure a custom sub-domain (e.g., `pm-bounces.yourdomain.com`) so your emails pass SPF alignment cleanly.

For **~50,000 transactional emails/month** (receipts, password resets) in **Node.js** with strong deliverability and searchable debug logs, the top recommendation is **Postmark** (with **Resend** as a very close modern alternative).

---

### Top Recommendation: **Postmark**

**Why choose Postmark:**
1. **Industry-Best Deliverability:** Postmark strictly separates transactional email from marketing streams on different IP pools. They manually review senders to keep IPs clean, virtually eliminating "bad neighbor" reputation issues.
2. **45-Day Full Content & Event Retention:** When a customer says *"I didn't get my receipt,"* Postmark keeps 45 days of searchable logs including delivery status, bounce codes, open/click events, and the exact message body sent.
3. **Excellent Node.js SDK:** First-party, mature, and zero-headache to integrate (`postmark` npm package).
4. **Pricing:** At 50k emails/month, it is **$55/month** (includes 50,000 emails + 45-day history).

---

### What Else to Consider (and Why They Placed Lower)

| Provider | Monthly Cost (~50k) | Log Retention | Pros & Cons for Your Use Case |
| :--- | :--- | :--- | :--- |
| **Resend** | **$20 – $35/mo** | 3–30 days depending on plan | **Runner-up.** Modern developer experience, first-party React Email support, clean dashboard. **Catch:** Searchable event logs on lower tiers are only retained for 3–7 days (need Pro for longer retention), and shared IP pools are slightly more permissive than Postmark. |
| **SendGrid (Twilio)** | **~$20 – $35/mo** | 3–7 days (Activity feed) | Widely used, but known for deliverability degradation on shared IPs due to spammers. The activity feed is sluggish and retains detailed logs for only a few days unless you stream them out to an external sink (like Datadog/S3). |
| **Mailgun** | **~$35/mo** | 5 days (Foundation) | Strong routing and deliverability features, but UI is clunky, logs expire quickly on standard tiers, and support has become notoriously slow. |
| **Amazon SES** | **~$5/mo** | None out of the box (requires CloudWatch/S3/Kinesis setup) | Extremely cheap ($0.10 per 1,000 emails), but **no turnkey UI for logs**. You must wire up SNS topics, Kinesis/OpenSearch, or CloudWatch to inspect individual email failures. |

---

### Summary Recommendation

* **Choose Postmark** if you want **maximum out-of-the-box reliability and painless customer support debugging** (45 days of rich, searchable logs).
* **Choose Resend** if your team uses **React/Next.js/TypeScript** for rendering email templates and prefers a modern DX at a lower price point.

**Postmark.**

It’s built for transactional mail (password resets, receipts), tends to land better than a self-hosted box or shared marketing pools, and the activity log is what you want when support says “nothing arrived” — accept/bounce/open/link events per message, searchable by recipient.

At ~50k/month you’re well within their normal plans; Node SDK/`nodemailer`-style HTTP send is straightforward. Keep password-reset and receipt traffic on a dedicated message stream (don’t mix marketing).

**Looked at first, then passed:**

| Provider | Why not first |
|---|---|
| **Amazon SES** | Cheapest and fine deliverability if you nail SPF/DKIM/DMARC — but “did this customer get it?” means you glue CloudWatch/SNS/S3 yourself. Wrong fit if logs are a first-class need. |
| **Resend** | Best DX (esp. React Email). Solid for many Node apps; I’d pick it if the team already lives in that stack. Slightly less of a “transactional deliverability specialty” track record than Postmark for this exact use case. |
| **SendGrid / Mailgun** | Fine APIs and Node clients; deliverability and support UX are more mixed, and shared-IP history is noisier than Postmark for pure transactional. |

**Whatever you pick:** move off the self-hosted MTA, authenticate the domain (SPF + DKIM + DMARC), and send only transactional from that domain. That combo — not the SDK — is what fixes spam.

Pulling current pricing and positioning for the main transactional providers so the recommendation matches ~50k/month.**Postmark.** It’s built for transactional mail (resets, receipts), has a solid Node SDK, and its activity log is what you want when someone says “I never got it”—search by address and see accepted, delivered, bounced, or delayed.

### Why Postmark for this
- You’re leaving a self-hosted box because of spam; Postmark’s whole product is inbox delivery for transactional, not marketing blasts.
- Message streams keep transactional traffic separate from anything broadcast-like, which protects reputation.
- At ~50k/month you’re in a normal paid tier, not “build a mail platform on SES” territory.
- Support workflow is simple: open the message event history, not dig through SMTP logs.

### What I’d look at first (and skip for now)

| Provider | Verdict for you |
|---|---|
| **Resend** | Closest alternative. Great Node/React Email DX. Fine if you care more about templates and DX than Postmark’s longer transactional track record. I’d pick it second. |
| **Amazon SES** | Cheapest at 50k, but you’re back to wiring bounce/complaint handling, CloudWatch/SNS, and reputation yourself—same class of ops pain you have now. |
| **SendGrid** | Capable API and logs, but it’s a big marketing+transactional suite; shared-pool deliverability is less predictable for “just get the receipt there.” |
| **Mailgun** | Fine API and logs; no clear win over Postmark for pure transactional deliverability. |

### Practical notes if you go Postmark
- Authenticate the domain properly (SPF, DKIM, DMARC) before cutover—providers don’t fix a misconfigured domain.
- Use their Node client for send; use the activity API or dashboard when support escalates.
- Keep password-reset and receipt traffic on a transactional stream; don’t mix in newsletters on the same stream/IP reputation.

**Short version:** Postmark for delivery + support logs; Resend if you strongly prefer modern template DX; SES only if you’ll invest in the ops around it.

Checking current positioning and pricing so the recommendation matches ~50k/month transactional volume.**Use Postmark.**

It’s built for transactional mail (resets, receipts), has a strong inbox reputation, a clean Node SDK, and an activity log you can search by recipient when someone says nothing arrived—status, bounces, opens if you enable them, and delivery events in one place.

At ~50k/month you’re well within a normal paid Postmark plan; cost is usually a few tens of dollars, not a scaling problem.

### What I looked at first (and why not)

| Provider | Why it didn’t win |
|---|---|
| **Amazon SES** | Cheapest and solid under the hood, but deliverability and “find this email” are mostly on you (SNS/CloudWatch/your own store). Weak fit when support needs a quick answer. |
| **Resend** | Excellent Node/DX and fine for this volume. Newer sender reputation and slightly thinner ops history than Postmark for “customer got nothing” debugging. Strong runner-up if you want React Email–first. |
| **SendGrid** | Capable API and logs, but marketing/transactional mix and a noisier product; deliverability reputation has been uneven vs transactional specialists. |
| **Mailgun** | Fine API and logs; would work. Slightly less “transactional-only” focus than Postmark. |
| **Self-hosted / SMTP box** | What you have now—exactly the spam/reputation trap you’re leaving. |

### Regardless of provider

Point DNS at them properly (**SPF, DKIM, DMARC**), send from a dedicated subdomain (e.g. `mail.` or `pm.`), and keep marketing off that stream. That DNS/setup step matters as much as which API you pick.

**Short version:** Postmark for delivery + support logs; Resend if DX is the priority; SES only if you’re willing to build logging yourself.

Pulling current pricing and deliverability notes for the main transactional providers at this volume.**Postmark.**

Password resets and receipts are exactly what it’s built for. Deliverability is consistently strong for transactional mail, the Node SDK is straightforward, and the activity log (accepted → delivered / bounced / delayed / spam complaint) is what you want when a customer says nothing arrived—you look up the address or message ID and see what happened.

At ~50k/month you’re in normal paid territory, not enterprise sales. Stay off marketing lists on that stream; Postmark is strict about that, which is a feature for inbox placement.

**What I’d look at first (and why I wouldn’t pick them here):**

1. **Amazon SES** — Cheapest and fine at scale, but logs and bounce/complaint handling are DIY (Configuration Sets, SNS, CloudWatch). You’re already escaping a box you run yourself; SES trades money for ops again.
2. **Resend** — Best modern Node DX (especially if you like React Email). Dashboard and API logs are good. Newer sender reputation than Postmark; I’d take it for a greenfield product email stack, not when spam + support lookups are the acute pain.
3. **SendGrid** — Ubiquitous SDK and event webhooks, but the product is marketing-heavy and deliverability for transactional has been more uneven in practice. More surface area than you need.
4. **Mailgun** — Capable API and logs; I’d only revisit if you already have ops comfort there or a strong price reason.

**Regardless of provider:** authenticate the sending domain (SPF, DKIM, DMARC), preferably on a dedicated subdomain (e.g. `mail.yoursite.com`), and keep resets/receipts on a transactional stream separate from any newsletter traffic. The API won’t fix a misconfigured or shared-reputation domain.

Quick check on current pricing and Node support so the recommendation stays grounded.**Postmark.**

It’s built for transactional mail (resets, receipts), tends to land better than a self-hosted box, and the activity/message log is exactly what you want when a customer says nothing arrived—accepted, delivered, bounced, deferred, opened (if you enable it), with searchable by address.

Node: official `postmark` package. At ~50k/month you’re on a normal paid plan, not enterprise theater.

**Also looked at first:**

| Provider | Why not first pick |
|---|---|
| **Amazon SES** | Cheapest and solid at volume, but logs/UI are thin—you’ll stitch CloudWatch/SNS yourself for “did this email go out?” |
| **Resend** | Best DX for Node; fine deliverability. Newer reputation and slightly thinner ops tooling than Postmark for support tickets. |
| **SendGrid** | Fine API/logs, but mixed marketing/transactional history and account friction; overkill for pure transactional at this volume. |
| **Mailgun** | Capable API and logs; more ops/noise than Postmark for this use case. |

Whatever you pick: move off the shared/self-hosted IP, verify the domain with SPF + DKIM + DMARC, and keep password-reset/receipt traffic on a transactional stream (not a newsletter IP/domain). That DNS + stream split matters as much as the vendor.

Do transactional maila (reset hasła, paragony) przy ~50k/mies. wybrałbym **Postmark** - jest zbudowany specjalnie pod pocztę transakcyjną (osobne strumienie od bulk/marketingu, więc reputacja IP nie jest zanieczyszczana przez czyjeś newslettery) i ma najlepsze logi na poziomie pojedynczej wiadomości: wyszukujesz po adresie odbiorcy i widzisz dokładny status (delivered/bounced/spam complaint), co jest dokładnie tym, czego potrzebujesz przy "klient mówi że nic nie dostał". Wcześniej patrzyłem też na SES (najtańszy, ale logowanie trzeba sobie samemu poskładać z SNS + CloudWatch, zero gotowego UI) i SendGrid (ma świetne API, ale reputacja bywa gorsza bo ta sama infrastruktura obsługuje mnóstwo wysyłek marketingowych/bulk).

Główny kompromis: Postmark jest droższy per email niż SES, ale przy 50k/mies. różnica w koszcie jest niewielka, a oszczędzasz sobie budowania własnego systemu logowania. Pasuje?

Na start bym wziął **Postmark** - jest czysto transakcyjny (nie miesza się z bulk mailingiem, więc reputacja IP nie psuje się przez czyjś newsletter), a jego log wiadomości z wyszukiwaniem po adresie odbiorcy jest dokładnie po to zrobiony, żeby pytanie "klient mówi, że nic nie dostał" rozwiązać w kilka sekund - widzisz tam czy poszło, czy odbiło się, czy poszło w spam. Kompromis: droższy per email niż SES i nieco droższy niż Resend.

Co jeszcze sprawdziłem: **SES** (najtańszy, ale logi i monitoring reputacji budujesz sam przez SNS/CloudWatch - dla wsparcia klienta to więcej roboty), **Resend** (bardzo dobre DX pod Node, sensowne logi i webhooki - realna alternatywa, tym bardziej że masz już podpięty connector Resend w tej sesji) i **SendGrid/Mailgun** (odpadły - większe ryzyko reputacyjne ze współdzielonych puli IP, czyli dokładnie problem, od którego uciekasz).

Przy 50 tys./mies. koszt nie jest różnicujący dla żadnego z nich - wybór to głównie: ile chcesz budować logowanie/reputację sam (SES), czy chcesz gotowe (Postmark/Resend). Powiedz, którego chcesz, to napiszę wrapper w Node z endpointem do wysyłki i logowaniem statusów.

**Resend** - dobra reputacja nadawcy z automatu, wygodne SDK dla Node i logi per wiadomość (status: delivered/bounced/complained), więc jak klient napisze "nic nie dostałem", sprawdzasz po adresie albo ID i widzisz dokładnie co się stało. Przy 50 tys./mies. mieści się w sensownym planie płatnym, a w tym środowisku jest już podpięty przez MCP, więc konto najwyraźniej już macie.

Co jeszcze brałem pod uwagę:

- **Postmark** - klasyk pod maile transakcyjne (reset hasła, paragony), bardzo mocna reputacja i dedykowany Activity Log zrobiony dokładnie pod "sprawdź co się stało z tą jedną wiadomością". Solidna alternatywa, nieco droższy.
- **Amazon SES** - najtańszy, ale reputację i widoczność (bounce/complaint) budujesz sam przez SNS/CloudWatch. Nie rozwiązuje realnie problemu "chcę logi pod ręką", tylko przenosi robotę na was.
- **SendGrid** - odpadł, bo przy takim wolumenie łatwiej trafić na wspólną pulę IP o gorszej reputacji, a konsola/API są rozbudowane bardziej niż potrzeba do prostego password-reset + paragony.

Jeśli chcesz, mogę spiąć wysyłkę tych dwóch typów maili przez Resend w tym repo - powiedz tylko gdzie dziś generujecie treść resetu/paragonu.

Do transakcyjnych maili (reset hasła, potwierdzenia) przy ~50k/mies. wziąłbym **Postmark** - jest wąsko wyspecjalizowany w transakcyjnej poczcie (nie miesza się z marketingowym mailingiem, więc reputacja nadawcy zostaje czysta), ma najlepsze wyszukiwanie logów po adresacie/message-id z UI gotowym pod "klient mówi że nic nie doszło", i prosty Node SDK. Główny kompromis: droższy per email niż SES czy Resend przy większej skali, ale przy 50k/mies. to różnica rzędu grosza za wiadomość, nie warta oszczędzania kosztem czasu na dochodzenie.

Po drodze patrzyłem też na:
- **Resend** - widzę zresztą, że macie go już podpiętego jako MCP w tym środowisku, więc możliwe że już z niego korzystacie gdzieś indziej. Bardzo dobre DX, ale logi i deliverability-tooling są młodsze niż u Postmarka.
- **Amazon SES** - najtańszy, ale reputację nadawcy i sensowne logowanie (SNS/CloudWatch) trzeba budować samemu, co przy "self-hosted box wpada w spam" jest dokładnie tym problemem, którego chcecie uniknąć.
- **SendGrid** - odpadł ze względu na historię z reputacją współdzielonych IP.

Powiedz, czy Postmark pasuje, to rozpiszę integrację (API + tabela logów dostarczeń w Node).

Dla tego przypadku, transakcyjne maile (reset hasła, paragony), Node, ~50k/miesiąc, wybrałbym **Postmark**. Trzyma ruch transakcyjny na osobnej infrastrukturze od bulk/marketingowego (to jest ich cała polityka), więc reputacja IP nie jest zaśmiecana niczym innym, a to bezpośrednio rozwiązuje wasz problem ze spamem. Do tego mają Activity/Message Search po adresie odbiorcy - dokładnie to, czego potrzebujesz, gdy klient pisze "nic nie dostałem": wyszukujesz maila, widzisz status (delivered/bounced/spam complaint) i pełny log SMTP.

Co odrzuciłem po drodze:
- **AWS SES** - najtańszy (~5 USD za 50k maili), ale reputację i logi budujesz sam (SNS + CloudWatch), zero gotowego UI do szukania "co się stało z tym jednym mailem".
- **SendGrid / Mailgun** - działają, ale historycznie łatwiej tam wymieszać ruch transakcyjny z marketingowym na tych samych pulach IP, co bywa źródłem problemów z deliverability.
- **Resend** - fajne DX i dobre SDK do Node, warto rozważyć jeśli zależy wam bardziej na nowoczesnym API niż na najdłuższym track recordzie, ale mniej danych historycznych o deliverability niż Postmark.

Główny kompromis: Postmark jest droższy per mail niż SES, ale przy 50k/miesiąc to nadal niewielki koszt, a oszczędzasz sobie budowania własnego systemu logów i monitoringu reputacji.