AgentMail vs Postmark

TL;DR

AgentMail gives AI agents their own email inboxes through a single API. Postmark is a transactional and broadcast email service with a strong deliverability reputation, an inbound webhook for receiving mail, and a recently released set of open-source Skills for AI coding agents. They solve different problems.

Postmark has been delivering transactional email since 2010. The send side is the core product. Inbound is supported through a webhook that posts the full message body, headers, and attachments to your endpoint as JSON. There is no inbox object, no persistent storage of conversations beyond the data retention window, and no per-agent address you can provision through the API.

AgentMail treats the inbox as the unit of the API. One call provisions a new one, and each inbox carries its own address, a message store that keeps everything, threading that happens on its own, webhooks and WebSockets, a place in a multi-tenant Pod, and an official skill for AI coding assistants.

When Postmark is the right call

• The workload is send-only or send-heavy: password resets, transactional notifications, receipts, broadcast newsletters.
• Deliverability is the top requirement and the team is willing to align with Postmark's sender vetting.
• The agent only needs to receive replies through a webhook to a single endpoint, not maintain a persistent inbox per agent.
• The team is already on ActiveCampaign or wants Postmark's Message Streams to separate transactional from broadcast sending infrastructure.

When AgentMail is the right call

• The agent needs its own email identity, not a from address on a shared sender.
• Every agent or tenant gets a scoped identity of its own: an address, an API key, and data nobody else can read.
• The agent keeps its memory in email, so the mail has to stay queryable as an inbox instead of as a stream of past webhook deliveries.
• You provision an inbox for every customer at signup and want that to be one API call.
• The agent reads and replies in-thread across many concurrent conversations.

What each one is built for

Postmark is a transactional and broadcast email service. The send side is the product: Email API, SMTP relay, Message Streams that separate transactional from broadcast traffic, server-side templates, bulk send, analytics, and a strong deliverability reputation since 2010. Postmark also supports inbound: you point an MX record at Postmark (or use a generated *@inbound.postmarkapp.com address), and inbound mail is posted to your webhook as JSON that includes the full body, headers, spam score, and Base64-encoded attachments. There is no inbox object, no thread model, and no per-address provisioning API. Inbound is locked to the Pro and Platform tiers.

AgentMail treats the inbox as the API object. Each Inbox gets an address, on the shared @agentmail.to domain or on a custom domain you have verified, plus a message store of its own, threading that follows In-Reply-To and References for you, webhooks and WebSocket connections for real-time inbound, and a Pod that keeps one tenant's data away from another's at the infrastructure level. Provisioning an inbox is client.inboxes.create(). Replying in-thread is client.inboxes.messages.reply(). The Quickstart walks through the full send-and-receive loop.

Skills for AI coding agents

The official AgentMail skill is open source on. Install with npx skills add agentmail-to/agentmail-skills and your coding assistant then knows the whole AgentMail surface: Inboxes provisioned on demand, Messages sent and answered inside Threads, Drafts held for a human to approve, tenants kept apart with Pods, attachments handled, applying idempotency keys for safe retries, and subscribing to real-time events over WebSockets or webhooks.

Postmark released its own skill on the same open-source format in February 2026 covering its send, inbound webhook, template, and webhook-configuration surfaces. The shape of each skill mirrors what the product is built around: Postmark's teaches agents how to send through a transactional API; AgentMail's teaches agents how to operate a full email identity on the internet.

The agent loop

Where the products diverge

Postmark's inbound webhook is more capable than most transactional APIs. The payload includes the full message body, all headers, a spam score, and Base64-encoded attachments. Compared to a transactional API where inbound is metadata-only, this is a real upgrade.

What it doesn't include is an inbox object. Each inbound message arrives as a single webhook event with a 45-day default retention window (extendable to 365 days on Pro and Platform). There is no API to list messages by address, no thread object grouping replies, and no API to provision a new inbound address on demand without configuring MX records or a +hash MailboxHash route. For workflows like email-to-ticket systems and reply-by-email confirmations, the Postmark webhook is genuinely good. For agents that need to act as a first-class participant on the internet over time, the inbox layer has to be built on top.

AgentMail is built around that primitive natively, and the inbox is only the starting point. An Inbox gives the agent its own identity on the internet: a real address that people, services, and other agents can send to, sign it up for things, and route verifications and replies to. Messages accumulate persistently in Threads, so the inbox doubles as long-term agent memory the agent can query later. Inbound arrives in real time over webhooks or WebSockets. Replies thread automatically through messages.reply without your code building the In-Reply-To and References headers. Tenants are isolated through Pods, with API keys scoped to a single pod or a single inbox. Per-inbox allowlists and blocklists filter senders before they reach the agent. Drafts support human-in-the-loop approvals for sensitive sends. And the same inbox is reachable over IMAP and SMTP when an ops team or legacy mail client needs standard access.

Pricing

Postmark

On Postmark's pricing page, dedicated IPs are $50/month and require Pro tier or higher with 300,000+ monthly sends, custom retention is a $5/month add-on (Pro and Platform), and inbound email processing is locked to Pro and Platform; it is not available on Basic.

AgentMail

Dedicated IPs are an Enterprise feature; talk to sales for those. The SOC 2 Type II report comes with Startup and above, retention is persistent on every plan, and the full price list is at agentmail.to/pricing.

A note on comparing these numbers

At the entry tier both products are similar in price ($15 Postmark Basic vs $20 AgentMail Developer). What you pay for is different. Postmark Basic gets you 10,000 sends with no inbound and no inbox layer. AgentMail Developer gets you 10 inboxes that send and receive, keep their mail, thread it automatically, and sit inside Pods: the inbox primitive rather than a send meter.

For send-only workloads at high volume, Postmark's per-email cost scales lower than AgentMail's per-inbox cost. For workloads that need persistent agent inboxes, the comparison is the inbox layer versus building it on top of Postmark's inbound webhook.

Code: the full agent loop

AgentMail

import os
from dotenv import load_dotenv
from agentmail import AgentMail
from agentmail.inboxes.types import CreateInboxRequest

load_dotenv()
client = AgentMail(api_key=os.getenv("AGENTMAIL_API_KEY"))

# Provision the agent's inbox in one call
inbox = client.inboxes.create(
    request=CreateInboxRequest(username="sales-agent")
)

# Send outbound
client.inboxes.messages.send(
    inbox_id=inbox.inbox_id,
    to="lead@example.com",
    subject="Quick question",
    text="Hi Alex, saw your post about email infrastructure...",
)

# Reply in-thread when a message.received webhook fires
def on_inbound_email(payload):
    message_id = payload["message"]["message_id"]
    client.inboxes.messages.reply(
        inbox_id=inbox.inbox_id,
        message_id=message_id,
        text="Thanks for getting back. To answer your question...",
    )

Postmark

import os
import requests

POSTMARK_TOKEN = os.environ["POSTMARK_SERVER_TOKEN"]

# Send outbound through the Postmark Email API
requests.post(
    "https://api.postmarkapp.com/email",
    headers={
        "Accept": "application/json",
        "Content-Type": "application/json",
        "X-Postmark-Server-Token": POSTMARK_TOKEN,
    },
    json={
        "From": "sales-agent@yourdomain.com",
        "To": "lead@example.com",
        "Subject": "Quick question",
        "TextBody": "Hi Alex, saw your post about email infrastructure...",
        "MessageStream": "outbound",
    },
)

# Inbound mail arrives at your webhook endpoint as JSON.
# Body and Base64 attachments are in the payload.
# Threading and per-agent identity are built in your application.
def on_inbound_email(payload):
    from_address = payload["From"]
    subject = payload["Subject"]
    text_body = payload["StrippedTextReply"]  # cleaned reply text
    in_reply_to = payload["Headers"]  # parse Message-ID for threading

    # Build a threaded reply manually
    requests.post(
        "https://api.postmarkapp.com/email",
        headers={
            "Accept": "application/json",
            "Content-Type": "application/json",
            "X-Postmark-Server-Token": POSTMARK_TOKEN,
        },
        json={
            "From": "sales-agent@yourdomain.com",
            "To": from_address,
            "Subject": f"Re: {subject}",
            "TextBody": "Thanks for getting back...",
            "MessageStream": "outbound",
            # In-Reply-To and References headers go here to thread correctly
        },
    )

The Postmark code works. What it carries with it is the threading logic, the per-agent identity routing (typically via MailboxHash or +suffix addressing), and the storage layer if you need conversation history beyond the 45-day default retention.

Identity and multi-tenancy

Postmark's identity unit is a server (and its server token). All sends go through a server's configured Message Stream and sending domain. Per-tenant routing is built in your application: a single inbound endpoint receives all mail and your code dispatches based on the To field or MailboxHash. Server tokens are scoped to a server, so larger fleets typically use separate servers per tenant (with the per-plan server limits on Basic, Pro, and Platform).

The unit of identity on AgentMail is the Inbox. Inboxes sit inside Pods, which keep tenants apart at the infrastructure level, and an API key can be scoped to one pod or one inbox, so a leaked credential in one tenant's environment never reaches another tenant's mail. Creating an inbox at customer signup is a single call.

Migrating from Postmark to AgentMail

Teams that started on Postmark for outbound and added inbound through the webhook often end up building an inbox layer on top: a database for messages, a thread reconstruction job, and per-tenant routing logic on a catch-all endpoint. The AgentMail migration replaces that custom layer with a real Inbox object.

Outbound is the smaller change. POST https://api.postmarkapp.com/email on Postmark becomes client.inboxes.messages.send on AgentMail (see the Quickstart). Inbound is the larger change: the catch-all webhook plus database plus threading code gets replaced by per-inbox provisioning, the message.received event, and client.inboxes.messages.reply for threaded replies. Postmark and AgentMail can run side-by-side during the transition, with Postmark handling pure outbound notifications and AgentMail handling the agent inbox surface.

Choosing between them

If your workload is send-heavy and you care about deliverability above all else, Postmark is a legitimate choice with a long track record and a thoughtful inbound webhook on top.

If your agent owns its own address, reads and replies across threads over time, or provisions a new mailbox per customer at signup, AgentMail is built around that primitive. The inbox is the API object.

The Free plan provisions real inboxes with full sending and receiving. No credit card required.