Top Email Infrastructure Next.js Support: 10 APIs Compared

The top email infrastructure Next.js support options in 2026 share three traits: an HTTP API you can call from a Server Action or Route Handler, a lightweight TypeScript SDK that will not break on Edge or serverless, and pricing that still works past the free tier. We ranked 10 providers on those criteria, verified every price on vendor pages on October 10, 2026, and corrected stale data still circulating in other roundups. For a broader view beyond Next.js, see our comparison of email delivery services for developers.

Top Email Infrastructure Next.js Support Compared

The table below compares each provider on the factors that decide Next.js fit: SDK weight, runtime notes, free tier, entry price, and the main limitation. SDK dependency counts come from the npm registry on October 10, 2026.

Rank	Provider	Best Fit	Node/TS SDK (Runtime Deps)	Next.js Runtime Notes	Free Tier	Entry Paid Plan	Main Limitation
1	Emercury SMTP Relay	Server Actions with retry safety and human support	@emercury/smtp-sdk (0)	Fetch-based; Node.js 18+ and browser runtimes per README. Edge not explicitly documented.	3,000/month or 100/day (waitlist)	Not publicly listed. Contact vendor.	Paid pricing unpublished; free tier on waitlist
2	Resend	React Email and Vercel Marketplace	resend (2)	react option is Node.js only	3,000/month, 100/day	$20/month, 50,000	Dedicated IP only on Scale
3	Postmark	Password resets and receipts	postmark (0)	HTTP API; Node 18+	100/month, permanent	$15/month, 10,000	Inbound only on Pro and above
4	SendPigeon	Budget Edge-friendly sending	sendpigeon (0, ESM-only)	Node.js and Edge per Next.js guide	3,000/month	$10/month, 10,000	Young platform; sends via AWS SES
5	Amazon SES	Lowest cost at volume	@aws-sdk/client-sesv2 (9)	IAM credentials; heavier SDK	None for SES; AWS credits	$0.16 per 1,000 (Essentials)	Sandbox until approved
6	Mailgun	Inbound routing and logs	mailgun.js (3)	Node.js; SDK uses axios	100/day	$15/month, 10,000	1-day logs on Free and Basic
7	MailerSend	Template builder plus API	mailersend (2)	Node.js	500/month, card required	$7/month, 5,000	Short logs on lower plans
8	Twilio SendGrid	Teams already on Twilio	@sendgrid/mail (2)	Node.js	60-day trial, 100/day	From $19.95/month	No permanent free plan
9	Nitrosend	AI agents sending email	@nitrosend/sdk (0)	ESM; Node 18+	8,000 to start, then 500/month	$20/month, 20,000	Young product; small team
10	Brevo	Transactional plus campaigns on a budget	@getbrevo/brevo (0)	Node 18+	300/day	$9/month, 5,000 credits	Higher-volume transactional pricing not listed

Sources for this table appear in each provider review below.

Comparison Summary: Five providers ship a Node SDK with zero runtime dependencies: Emercury, Postmark, SendPigeon, Nitrosend, and Brevo. Only SendPigeon documents Edge compatibility in writing. SendGrid and Amazon SES are the only providers here without a permanent free plan, and Emercury is the only one without published paid pricing.

How EPR Evaluated Next.js Email Infrastructure

We scored each provider on eight criteria that decide whether email works reliably from a Next.js app, not on features that matter only to marketers. Scoring is based on vendor documentation, vendor pricing pages, and the npm registry. We did not run send-volume or inbox-placement tests, so this ranking does not claim one provider delivers better than another.

How We Scored Top Email Infrastructure Next.js Support

The eight criteria and why each one matters in Next.js:

1. HTTP API callable from server code. Vercel calls the HTTP path “the more reliable of the two” compared with SMTP, because functions can stop once they respond.
2. SDK weight and runtime fit. The Edge runtime does not support native Node.js APIs, and packages must use ES modules. Fewer dependencies mean fewer surprises.
3. Retry safety. Serverless platforms retry on timeout. An idempotency key stops a retried call from sending twice.
4. Free tier for development. You need enough volume to test sign-up, reset, and receipt flows across environments.
5. Pricing transparency at 50,000 and 100,000 emails. Most Next.js SaaS apps cross the free tier within months.
6. Deliverability controls. Dedicated IP options, stream separation, and suppression handling protect transactional email delivery.
7. Observability. Log retention and webhooks let you answer “did the reset email arrive?”
8. Support model. Human support matters when a verification email silently fails in production.

EPR Verdict: No provider wins every criterion. The ranking weights runtime fit and retry safety highest because those decide whether a Next.js send succeeds at all. Pricing and deliverability controls break ties.

The 10 Best Email Infrastructure Providers for Next.js

Each review covers Next.js fit, pricing checked on October 10, 2026, strengths, and limitations. Prices are list prices in US dollars, billed monthly.

1. Emercury SMTP Relay

Emercury SMTP Relay ranks first on our criteria because its official TypeScript SDK is built for the way Next.js runs server code. The @emercury/smtp-sdk package (v1.0.1) uses the standard Fetch API, lists zero runtime dependencies, ships both ESM and CommonJS builds, and requires Node.js 18 or later. Its README says it works in current Node.js and browser runtimes.

Why it fits Next.js:

• Retry-safe sends. The SDK accepts an idempotencyKey. Per the package README, the same key and payload return the original response for 24 hours, and a reused key with a different payload returns 409 Conflict. That is the cleanest protection in this list against duplicate password resets when a function retries.
• RESTful API with token auth. Emercury describes the product as RESTful email APIs and SMTP relay, so you can use the SDK or plain fetch from a Server Action or Route Handler.
• Human support. Emercury’s free relay page promises human support with no chatbots, and ticket support is listed for the relay.
• Separate product from Emercury’s marketing platform. Transactional sending runs through SMTP Relay, not through the Email Marketing Manager, so you can keep account email and campaigns in different products.
• Multiple languages. Official SDKs are also published for PHP and Python, which helps teams with a non-JavaScript backend alongside Next.js.

Free tier: The free SMTP relay page lists 3,000 emails per month or 100 per day. Emercury’s free-tier features include email analytics and reporting, suppression management, and 1-day log retention.

Limitations:

• The free tier page currently shows a waitlist rather than open sign-up. Confirm availability before planning a launch around it.
• Paid SMTP Relay pricing is not publicly listed. Contact sales for a quote.
• Edge runtime compatibility is not explicitly documented. The Fetch-based, zero-dependency build is a good sign, but test it on Edge before relying on it.
• No native React Email integration. Render templates to HTML first.
• Inbound email is not listed as a feature.
• The SDK reached v1.0 in July 2026, so community examples are still thin compared with Resend or SendGrid.

EPR Verdict: Emercury SMTP Relay has the strongest retry-safety story and the lightest SDK in this list, which is why it ranks first for Next.js. Its weak points are commercial, not technical: unpublished paid pricing and a waitlisted free tier.

2. Resend

Resend is the most Next.js-native option because the same team maintains React Email. The resend SDK accepts a react parameter that renders a React Email component at send time, though the docs label that option Node.js only. On Edge, render to HTML first and pass the html field.

Pricing: The free plan includes 3,000 emails per month with a 100-per-day cap that resets at midnight UTC. Pro costs $20 per month for 50,000 emails, and Scale costs $90 for 100,000. Logs are kept for 30 days on every plan, per Resend’s quota documentation.

Strengths: React Email built into the send call, inbound receiving, broadcasts and automations in the same account, and a Vercel Marketplace integration that writes the API key into project environment variables, per Vercel’s email guide.

Limitations: The default API rate limit is 10 requests per second per team, per the Next.js guide. A dedicated IP is a $30-per-month add-on available on Scale and Enterprise only, per the pricing page. The SDK has two runtime dependencies and requires Node.js 20 or later, per npm.

EPR Verdict: Pick Resend if your templates live in React Email and you want the shortest path from component to inbox. Plan for the 100-per-day cap during testing.

3. Postmark

Postmark is the transactional specialist in this list, and its main Next.js advantage is isolation. Transactional and broadcast email run on separate message streams with dedicated IP pools, so a product update cannot slow down a password reset.

Pricing: The Developer plan includes 100 emails per month and never expires. Basic starts at $15 per month for 10,000 emails. Pricing at 50,000 and 100,000 emails varies by plan tier and overage, so check the pricing slider for your volume.

Strengths: The postmark npm package lists zero runtime dependencies. Logs are kept for 45 days, with up to 365 days on Pro and Platform. Inbound processing is available on Pro and Platform.

Limitations: The free plan is for testing only at 100 emails per month. Dedicated IPs start at $50 per month and require 300,000 or more emails per month, per the pricing page.

EPR Verdict: Choose Postmark when transactional reliability matters more than price, especially for login codes and receipts.

4. SendPigeon

SendPigeon is the only provider in this list that states Edge compatibility in its Next.js documentation, where its guide describes the SDK as compatible with Node.js and Edge Runtime. The sendpigeon package is ESM-only with zero runtime dependencies.

Pricing: The free plan includes 3,000 emails per month with no credit card. Starter costs $10 for 10,000 emails, Growth $15 for 30,000, Pro $39 for 100,000, and Scale $89 for 300,000.

Strengths: Low entry pricing, a local development server, and sequences and broadcasts alongside transactional sending.

Limitations: Delivery runs on Amazon SES, per the site footer, so you are paying for a developer layer over SES. Log retention is 3 days on Free and 7 on Starter. Inbound plan availability is inconsistent between the docs and the pricing page. No dedicated IP option is listed.

EPR Verdict: A good budget choice for Edge-first apps. Weigh the short log retention on lower plans.

5. Amazon SES

Amazon SES is the lowest-cost option at volume, and the hardest to set up. Since July 21, 2026, new accounts default to the Essentials plan at $0.16 per 1,000 emails with no monthly fee. You can switch to a la carte pricing at $0.10 per 1,000.

Next.js fit: The @aws-sdk/client-sesv2 package pulls in nine runtime dependencies and requires Node.js 20 or later, per npm. Authentication uses IAM credentials, which you must store as server-only environment variables on Vercel.

Limitations: There is no SES-specific free tier for new accounts. New AWS customers get general Free Tier credits instead. Every new account starts in the SES sandbox, limited to verified recipients, 200 messages per 24 hours, and 1 message per second until AWS approves production access. You build templates, bounce handling, and dashboards yourself.

EPR Verdict: Choose SES when volume is high and your team already runs on AWS. For a small Next.js app, the setup cost outweighs the savings.

6. Mailgun

Mailgun suits Next.js apps that need inbound routing and detailed event logs. The free plan allows 100 emails per day with 1 domain, 1 inbound route, and 1-day logs.

Pricing: Basic starts at $15 per month for 10,000 emails. Foundation costs $35 for 50,000, and Scale costs $90 for 100,000. Logs are kept 5 days on Foundation and 30 days on Scale.

Limitations: The mailgun.js SDK depends on axios plus two other packages, so prefer a plain fetch call on Edge. Mailgun’s pricing page gives conflicting information about which plan includes a dedicated IP, so confirm with sales.

EPR Verdict: Strong for inbound workflows and log depth from Foundation upward. The 1-day logs on lower plans limit debugging.

7. MailerSend

MailerSend pairs a sending API with drag-and-drop and HTML template builders. The free plan includes 500 emails per month and 100 API requests per day, and requires card details.

Pricing: Hobby costs $7 per month for 5,000 emails. Starter costs $35 at 50,000 emails and $68 at 100,000.

Limitations: Activity logs are kept for 1 day on Free and Hobby, and 7 days on Starter. The pricing page quotes two different Starter overage rates, so confirm before you budget for spikes.

EPR Verdict: A reasonable middle option if non-developers need to edit templates outside your repository.

8. Twilio SendGrid

SendGrid remains one of the most mentioned services in Next.js community threads, but its free offer has changed. The permanent free plan is gone, replaced by a 60-day trial at 100 emails per day with no card required.

Pricing: Essentials starts at $19.95 per month. Pro starts at $89.95 and includes a dedicated IP.

Limitations: Logs are kept 3 days on Essentials and 7 days on Pro and Premier. Several 2026 roundups still call SendGrid the best free option, which is no longer accurate.

EPR Verdict: Choose SendGrid if your team already uses Twilio or needs its scale and subuser tools. New projects have cheaper paths to production.

9. Nitrosend

Nitrosend targets teams that want an AI assistant to send and manage email. The free plan includes 8,000 starting emails, then 500 per month, with no card required. Pro costs $20 per month for 20,000 emails, and Ultra costs $100 for 125,000.

Strengths: The @nitrosend/sdk package has zero runtime dependencies. Transactional, campaign, and flow sending share one plan.

Limitations: Daily sending limits range from 100 to 5,000 on Free depending on sender standing. Dedicated IPs start on Ultra at $50 per IP per month. The company’s own ranking page scores its track record and support 4 out of 10.

EPR Verdict: Interesting for agent-driven workflows. Riskier for core account email until its track record grows.

10. Brevo

Brevo combines transactional email with campaigns, SMS, and WhatsApp. Next.js developers on r/nextjs report calling its API from Route Handlers, and the official @getbrevo/brevo package lists zero runtime dependencies on npm.

Pricing: The free plan allows 300 sends per day with transactional email included. Starter begins at $9 per month for 5,000 email credits.

Strengths: Brevo’s pricing FAQ lists unlimited log retention for transactional email, and up to 1,000 extra transactional emails are queued for retry after the daily free cap.

Limitations: Brevo does not publish transactional-only pricing at 50,000 or 100,000 emails on its pricing page. Dedicated IPs are Enterprise only.

EPR Verdict: Fine for small apps that also need light campaigns. Teams scaling transactional volume should request a quote before committing.

Also Considered

These tools appear in the Next.js email conversation but did not make the ranked list:

• Loops. Priced by contacts rather than sends. Transactional emails use published templates sent by ID, so raw React Email HTML does not drop in directly.
• Mailer To Go. Named in Google’s AI Overview for Vercel Marketplace provisioning, but Vercel’s own email guide does not list it, and we could not confirm the integration.
• Nodemailer. A sending library, not infrastructure. Covered in the runtime section below.
• EmailJS. A client-triggered template service. Covered below.

Email API Pricing for Next.js Apps

Email API pricing is usually based on monthly volume, with daily caps on free plans and log retention or dedicated IPs reserved for higher tiers. The table shows list prices checked on October 10, 2026.

Provider	Free Tier	~10,000/month	~50,000/month	~100,000/month	Log Retention (Entry)
Emercury SMTP Relay	3,000/month or 100/day (waitlist)	Not publicly listed	Not publicly listed	Not publicly listed	1 day (free)
Resend	3,000/month, 100/day	$20 (Pro, 50k)	$20	$90 (Scale)	30 days
Postmark	100/month	$15 (Basic)	Requires plan review	Requires plan review	45 days
SendPigeon	3,000/month	$10 (Starter)	$39 (Pro, 100k)	$39	3 days (free)
Amazon SES	None for SES	$1.60 Essentials / $1.00 a la carte	$8 / $5	$16 / $10	Not listed
Mailgun	100/day	$15 (Basic)	$35 (Foundation)	$90 (Scale)	1 day
MailerSend	500/month	$7 (Hobby, 5k) plus overage	$35 (Starter)	$68 (Starter)	1 day
Twilio SendGrid	60-day trial	From $19.95	Requires plan review	From $89.95 (Pro)	3 days
Nitrosend	8,000, then 500/month	$20 (Pro, 20k)	Requires plan review	$100 (Ultra, 125k)	Not listed
Brevo	300/day	Requires plan review	Not confirmed	Not confirmed	Unlimited (per FAQ)

Amazon SES figures are per-1,000 rates multiplied by volume, before attachment fees. “Requires plan review” means the vendor uses a slider or overage model that does not map cleanly to one figure.

Pricing Snapshot: At 50,000 emails a month, Resend at $20 and SendPigeon at $39 are the cheapest self-serve managed options. SES is cheaper still if you can absorb the setup work.

How Next.js Sends Email: Runtimes, Server Actions, and Route Handlers

Next.js sends email from server code only, and where that code runs decides which provider and SDK will work. This section covers the runtime rules that most provider roundups skip.

Node.js Runtime vs Edge Runtime

The Node.js runtime is the default and has access to all Node.js APIs. The Edge runtime supports fetch but not native Node.js APIs, and packages must use ES modules. That rule removes SMTP libraries from Edge entirely and makes heavy SDKs risky. A Fetch-based SDK with zero dependencies, or a plain fetch call, is the safest choice on Edge.

Server Actions vs Route Handlers

Use a Server Action for user-triggered sends and a Route Handler for machine-triggered sends.

• Server Actions fit sign-up, contact, and password-reset forms. Next.js warns that a Server Action is reachable via a direct POST request, not just through your UI. The same guide names sending email as an expensive operation to rate-limit.
• Route Handlers fit webhooks, such as a Stripe payment event that triggers a receipt. They give you full control over the request, the response code, and signature verification.

Here is a Server Action that sends a password-reset email with Emercury’s SDK and an idempotency key derived from the reset token. The key stays stable across retries, so a retried call cannot send twice.

// app/actions/send-reset.tsx
'use server'

import { Configuration, EmailApi } from '@emercury/smtp-sdk'
import { render, toPlainText } from 'react-email'
import ResetEmail from '@/emails/reset'

const emails = new EmailApi(
  new Configuration({ apiKey: process.env.EMERCURY_API_TOKEN })
)

export async function sendResetEmail(userId: string, email: string, token: string) {
  // Validate input and rate-limit before this point.
  const html = await render(<ResetEmail token={token} />)

  await emails.sendEmail({
    idempotencyKey: `reset-${userId}-${token}`,
    sendEmailRequest: {
      from: { email: 'no-reply@yourdomain.com', name: 'YourApp' },
      to: { email },
      subject: 'Reset your password',
      contents: [
        { contentType: 'text/plain', content: toPlainText(html) },
        { contentType: 'text/html', content: html },
      ],
    },
  })
}

The README documents the text/plain content type. Confirm the exact HTML content type value in Emercury’s API reference before shipping.

Send After the Response With after()

The after() function schedules work once the response is finished, and it works in Server Functions and Route Handlers. Wrap non-critical sends, such as welcome emails, in after() so the user does not wait on the email API. It still runs within the route’s maximum duration, and it runs even if the response failed. Do not use it for sends where the UI must confirm success, such as “Check your inbox for a code.”

Why Proxy (Formerly Middleware) Is the Wrong Place to Send Email

Next.js 16 renamed middleware to proxy and made the Node.js runtime its default. Proxy runs before matched routes, and the docs recommend using it only as a last resort. An email call there adds latency to page requests and can fire on far more requests than intended. Any guide that says middleware runs only on Edge predates Next.js 16.

Can I Use Nodemailer With Next.js?

Yes, but only in the Node.js runtime, and with care. Vercel blocks outbound SMTP on port 25 but allows ports 465 and 587, and the Edge runtime has no raw socket access. You must await the send or schedule it with after(), because a function pauses background work once it responds. Vercel recommends an HTTP email API for production traffic. If you are deciding between a raw relay and a managed provider, our guide to SMTP relay vs email service provider explains the tradeoff.

Is EmailJS Safe for a Next.js App?

EmailJS works for simple contact forms because it triggers predefined templates from client code. The vendor itself acknowledges that someone could copy your public keys. That makes it a poor fit for password resets, verification codes, or anything tied to user accounts. Use a server-side API for those.

React Email and Next.js Templates

React Email is a template library, not a sending service. Its render() function is async and turns a component into an HTML string, and toPlainText() produces the plain-text part. You then pass that HTML to any provider in this guide.

Two details prevent common bugs:

1. Always await render(). A missing await sends a Promise instead of your email.
2. Send both HTML and plain text. Some clients and accessibility tools rely on the text part.

Resend is the only provider here whose SDK accepts the component directly, and only in Node.js. Loops is the exception in the other direction, because it sends transactional email from published templates rather than raw HTML.

Deliverability Setup Before You Send From Next.js

Production sending from any provider requires a verified domain with SPF and DKIM records, and a DMARC policy is strongly recommended. Google’s email sender guidelines require authentication for all senders and stricter rules for bulk senders. If these terms are new, start with how email deliverability works.

Setup Checklist:

• Send from a subdomain, such as mail.yourdomain.com, to separate app email from your corporate mailbox.
• Add the provider’s SPF and DKIM records, then publish a DMARC record.
• Store API keys in server-only environment variables. Next.js inlines anything prefixed with NEXT_PUBLIC_ into the browser bundle.
• Subscribe to bounce and complaint webhooks, and keep suppressed addresses out of future sends.
• Use separate API keys for preview and production deployments.

Best Email Infrastructure for Next.js by Use Case

The right provider depends on what your app sends and how it is deployed.

Use Case	Pick	Why
Password resets and login codes with retry safety	Emercury SMTP Relay	Idempotency keys and a zero-dependency Fetch SDK
Templates written in React Email	Resend	Native react option in Node.js
Strict isolation of transactional and broadcast mail	Postmark	Separate IP pools per message stream
Edge-first app on a small budget	SendPigeon	Documented Edge support, $10 entry plan
High volume on AWS	Amazon SES	$0.10 to $0.16 per 1,000 emails
Heavy inbound routing	Mailgun	Inbound routes and longer logs from Foundation
Non-developers editing templates	MailerSend	Visual and HTML builders
Existing Twilio stack	Twilio SendGrid	Shared account and billing
AI agents sending email	Nitrosend	Agent tooling and one plan for all streams
Transactional plus light campaigns	Brevo	300/day free with campaigns included

How to Choose and Migrate Email Infrastructure in Next.js

A safe choice comes down to five checks, and a safe migration comes down to keeping the provider behind one interface.

Buyer Checklist:

1. Confirm the SDK runs in your target runtime, or plan to call the REST API with fetch.
2. Confirm the free tier covers preview, staging, and production testing without hitting daily caps.
3. Price your expected volume at 12 months, not just today.
4. Check log retention against how long support tickets take to reach you.
5. Ask whether dedicated IPs are available at your volume, and what they cost.

Migration Steps:

1. Wrap every send in a single server-only module, so swapping providers touches one file.
2. Verify the new domain records before moving traffic.
3. Export your suppression list and import it into the new provider.
4. Shift a small share of traffic first and compare bounce and complaint rates.
5. Keep the old provider’s webhooks active until in-flight events settle.

Compare Email Infrastructure Independently With EPR

Email Platform Review is an independent review platform for ESPs, SMTP relays, and transactional email tools. If you are narrowing a shortlist for your Next.js app, use our provider reviews and comparisons to check pricing, deliverability controls, and limits before you commit. Start with our comparison of email delivery services for developers, then read the individual reviews for the providers on your list.

FAQs

What is the top email infrastructure for Next.js in 2026?

On EPR’s Next.js criteria, Emercury SMTP Relay ranks first because its official TypeScript SDK uses the Fetch API, ships with zero runtime dependencies, and supports idempotency keys. Resend is the strongest pick if you want React Email built into the send call. Postmark leads when separating transactional and broadcast traffic matters most. Confirm Emercury’s free-tier availability before planning around it.

What’s your go-to transactional email service for Next.js?

Next.js community threads mention Resend and SendGrid most often, and some developers report using Brevo’s API from Route Handlers. Popularity is a weak tiebreaker, though. Pick the provider whose SDK runs cleanly in your runtime, whose free tier covers your test volume, and whose pricing still works at 50,000 to 100,000 emails a month.

Does Brevo’s API work with Next.js Route Handlers?

Yes. Any provider with an HTTP API works from a Route Handler or Server Action, because the call runs on your server. Brevo’s official Node package, @getbrevo/brevo, lists zero runtime dependencies on npm. Its free plan allows 300 sends per day. Keep the API key in a server-only environment variable without the NEXT_PUBLIC_ prefix.

What’s the best service to send emails to users from a Next.js app?

Separate the job first. Password resets, receipts, and verification codes need a transactional API with good logs, retries, and suppression handling. Newsletters and lifecycle campaigns need list management and automation. Most Next.js teams start with a transactional provider from this list, then add a marketing platform once campaign volume justifies a second tool.

Can I use Nodemailer with Next.js on Vercel?

Yes, in the Node.js runtime only. Vercel blocks outbound SMTP on port 25 but allows ports 465 and 587, and the Edge runtime cannot open raw sockets at all. You must await the send or schedule it with after(). Vercel recommends an HTTP email API for production traffic, so treat Nodemailer as a fallback.

Is EmailJS a good choice for a Next.js app?

EmailJS suits simple contact forms on static sites because it triggers predefined templates from client-side code. It is a weak fit for account email such as password resets, because the trigger keys live in the browser and the templates sit in a third-party dashboard. Use a server-side transactional API for anything tied to user accounts.

Do I need React Email to send email from Next.js?

No. React Email is an open-source template library, not a sending service. It renders components to an HTML string, and you pass that HTML to any provider in this guide. Resend’s SDK also accepts a React component directly, but its docs mark that option as Node.js only. On Edge, render to HTML first.

Should I send email from a Server Action or a Route Handler?

Use a Server Action for user-triggered forms such as sign-up, contact, or password reset. Use a Route Handler for machine-triggered events such as Stripe or auth webhooks. Both run on the server. Treat every Server Action as a public POST endpoint: validate input, check authorization, and rate-limit anything that sends email.

Can I send email from Next.js proxy, formerly called middleware?

Avoid it. Next.js 16 renamed middleware to proxy, and proxy runs before every matched route. The docs recommend using it only as a last resort. An email call there adds latency to page requests and can fire far more often than intended. Send from a Server Action or Route Handler instead, and use after() for non-blocking sends.

Which email APIs work in the Next.js Edge runtime?

Any API you can call with fetch works on Edge, because Edge supports fetch but not native Node.js APIs or raw sockets. SendPigeon documents Edge compatibility in its Next.js guide. Emercury, Postmark, and Nitrosend ship zero-dependency SDKs, which helps, but test them on Edge yourself. Resend’s react option is Node.js only.

How do I stop duplicate emails when a Next.js function retries?

Send an idempotency key with each request. Emercury’s SDK accepts one and returns the original response for 24 hours when the same key and payload repeat, and a 409 Conflict when the payload differs. Derive the key from a stable value, such as the user ID plus the event ID, rather than a fresh random UUID per retry.

Is SendGrid still free for Next.js projects?

Not permanently. Twilio SendGrid replaced its permanent free plan with a 60-day trial capped at 100 emails per day, with no card required. After the trial, paid Essentials plans start at $19.95 per month. Several 2026 roundups still describe a permanent SendGrid free tier, so verify on the live pricing page.

How much does email infrastructure for a Next.js app cost at 50,000 emails a month?

List prices checked October 10, 2026: Resend Pro is $20, Mailgun Foundation is $35, and MailerSend Starter is $35. Amazon SES costs about $8 on the default Essentials plan or $5 a la carte, before attachment fees. Emercury has not published paid SMTP Relay pricing yet, so contact sales for a quote.

Do I need SPF, DKIM, and DMARC before sending from Next.js?

Yes for production. Every provider here asks you to verify a sending domain, which means adding DNS records for SPF and DKIM. A DMARC record tells receiving servers how to treat mail that fails those checks. Set all three before launch, because Gmail requires authentication from every sender and applies stricter rules to bulk senders.

How do I migrate a Next.js app from one email provider to another?

Wrap sending in one server-only function so the provider sits behind a single interface. Verify the new domain records, export your suppression list, and import it before the first send. Then shift a small share of traffic, compare bounce and complaint rates, and cut over fully. Keep the old provider’s webhooks running until in-flight events settle.

Should transactional and marketing email use the same provider in a Next.js app?

Not necessarily. Keeping them on separate products or streams stops a bad campaign from delaying password resets. Postmark separates the two with dedicated IP pools per stream. Emercury sells SMTP Relay and its Email Marketing Manager as separate products. Resend and Nitrosend combine both on one account, which simplifies billing but couples the two workloads.

Can I use these providers with a NestJS backend?

Yes. NestJS runs on Node.js, so every SDK in this guide works there without Edge restrictions. Wrap the provider in an injectable mail service, read the API key from configuration, and queue sends with a job runner so request handlers return quickly. The runtime caveats in this guide apply mainly to Next.js on serverless and Edge platforms.