Switching from Mailgun, form-encoding and all

Mailgun integrations are wire-level habits — Basic auth as api:key, form-encoded bodies, a comma-separated to. All three work here unchanged. What that covers, what it doesn't, and what Mailgun still does better.

Facts verified 2026-08-29 — corrections: hello@emailfast.dev

Keep your client

With mailgun.js, the switch is a key and a url:

  import formData from "form-data";
  import Mailgun from "mailgun.js";

  const mg = new Mailgun(formData).client({
    username: "api",
-   key: process.env.MAILGUN_API_KEY,
+   key: process.env.EMAILFAST_API_KEY, // ef_sandbox_… works everywhere
+   url: "https://api.emailfast.dev",
  });

That works because SendGrid-, Mailgun-, and Postmark-compatible endpoints: point your existing SDK at a new base URL with a new key and keep your code — attachment sends are the one exception, refused with a clear error in your provider's own format rather than silently dropped. What the Mailgun-compatible endpoint honors, verified against the code that serves it:

• POST /v3/:domain/messages, same shape — HTTP Basic auth as api:<key>, and both encodings Mailgun clients actually use: form-urlencoded and multipart.
• A comma-separated to fans out to one message per recipient in either encoding. A policy block on any recipient rolls back the whole call with a truthful error — nothing half-queued.
• cc, bcc, and o:deliverytime carry over — cc/bcc with display names intact, and a future o:deliverytime schedules the send instead of being silently ignored.
• The response is Mailgun-shaped: { "id": "<…@yourdomain.com>", "message": "Queued. Thank you." }, so response-parsing code keeps working.
• Attachments and recipient-variables are refused loudly. Outbound attachments aren't supported yet, platform-wide — a send carrying one, as a form field or a multipart file part, gets a Mailgun-shaped 400 saying so, never a message quietly sent without its file. Per-recipient %recipient.x% substitution has no equivalent here, so recipient-variables is refused too rather than half-honored. Mailgun-only toggles (o:dkim, o:testmode, tracking overrides, and the like) are accepted without effect; native platform policy applies.
• Retries can be made safe with an Idempotency-Key header — each recipient in a fan-out gets its own derived key: a 202 from the API means the send is committed to a durable, partitioned outbox before we answer — a crash can't lose it, and a retry with the same idempotency key can't double-send.

However it arrives, every message passes the same checkpoint: every send — REST, SMTP, browser SDK, compatibility endpoints, broadcasts, automations — passes through one admission gate: idempotency, suppression, quota, and content policy in a single checkpoint no ingress can skip.

How long it actually takes

Everything above can run dry before production moves: sandbox keys (ef_sandbox_…) that run the real pipeline dry: real validation, real rendering, real events, a hosted capture inbox — and no email leaves.

What Mailgun publishes at your volume

Detail: Free plan: 100 emails/day. Volume selector on the pricing page repriced live: Basic $15 (10k incl.), Foundation $35 (50k incl.) / $75 (100k incl.), Scale $90 (100k) / $215 (250k) / $400 (500k) / $550 (750k) / $700 (1M). Foundation and Scale are 'free for 1 month' trials. Overages: from $1.80/1,000 (Basic), $1.30/1,000 (Foundation), $1.10/1,000 (Scale). Dedicated IP $59/mo. 2.5M+ = talk to sales. Prices shown are monthly billing in USD.

Figures verified 2026-08-29 on the Mailgun (Sinch) pricing page, promo and intro discounts excluded — method and corrections via the claims methodology.

Mailgun's mid-to-high-volume pricing is genuinely aggressive — check it against your real numbers rather than taking this page's word: 50,000 sends/month, 250,000, or 1,000,000.

Where Email Fast stands

Our stake, declared: we make Email Fast, and these are the launch prices already published on our pricing page — during early access they may be refined before general availability, and self-serve checkout opens at GA. Contacts and subscribers are never billed, at any list size.

Where Mailgun wins

From our own pricing survey, their side stated plainly — Developer-first API with best-in-class inbound parsing/routing, strong email validation product, and aggressive per-volume pricing at mid-to-high send volumes.

Honest additions: if inbound parsing is the core of your product, Mailgun set the bar and you should hold us to it in a sandbox test before switching anything. And their email validation is a mature standalone product. The full comparison: Mailgun vs Email Fast.

Next

• The step-by-step migration guide
• Also pricing SendGrid or Postmark?
• Suspended by your current platform? Read that first.
• Apply for early access — live sending starts by application

Mailgun is a trademark of its owner; Email Fast is not affiliated with or endorsed by them. Mailgun facts were verified on their public pages on the dates shown — corrections: hello@emailfast.dev.