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 is built around the inbox as the primitive. Each inbox has its own address, persistent message store, automatic threading, webhooks, WebSockets, multi-tenant pods, and an official skill for AI coding assistants. Provisioning a new inbox is one API call.

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.
• Each agent or tenant needs a scoped identity: own address, own API key, isolated data.
• Email serves as long-term agent memory and must remain queryable as a real inbox, not as a stream of past webhook deliveries.
• The product provisions inboxes per customer at signup and needs the operation to be a single 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 is built around the inbox as the API object. Each Inbox has its own address on either the shared @agentmail.to domain or a custom domain you verify, with its own message store, automatic threading via In-Reply-To and References headers, webhooks, WebSocket connections for real-time inbound, and Pods that isolate one tenant's data from another 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 an AI coding assistant gets first-class knowledge of the full AgentMail surface: provisioning Inboxes on demand, sending and replying to Messages inside Threads, managing Drafts for human-in-the-loop approvals, isolating tenants with Pods, handling Attachments, 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

Source: Postmark's published pricing as of May 2026. 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). Inbound email processing is locked to Pro and Platform; it is not available on Basic.

AgentMail

Dedicated IPs and SOC 2 Type II report on Startup and above. Persistent retention on every plan. Full pricing 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 with full send and receive, persistent storage, automatic threading, Pods, and the inbox primitive.

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).

AgentMail's identity unit is the Inbox. Inboxes group into Pods, and Pods isolate tenants at the infrastructure level. API keys scope to a pod or to a single inbox, so a credential issue in one tenant's environment can't reach another's mail. Provisioning a new inbox at customer signup is one API 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.

Frequently asked questions

Does Postmark have inbox objects? No. Postmark accepts inbound mail at a configured address (yours or a generated *@inbound.postmarkapp.com) and fires a webhook with the parsed message as JSON. There is no inbox resource, no thread object, and no per-address provisioning API.

Is the Postmark inbound webhook payload complete? Yes for the immediate event. The payload includes the full body, headers, spam score, and Base64-encoded attachments. Postmark is more complete than transactional APIs that send metadata-only webhooks. What it doesn't include is persistent inbox storage or thread grouping across messages.

How long does Postmark retain inbound emails? 45 days by default. Customizable up to 365 days as an add-on on Pro and Platform tiers. AgentMail retains messages persistently on every plan.

Is Postmark inbound available on every plan? No. Inbound email processing is locked to Pro and Platform. The Basic plan ($15/month) does not include inbound.

Both products have an AI coding agent skill. What's the difference? The AgentMail skill teaches agents to operate a full inbox identity: create inboxes, send, reply in threads, manage drafts, and isolate tenants through Pods. Postmark's skill teaches agents how to call Postmark's send, inbound webhook, and template surfaces correctly.

Can I use both AgentMail and Postmark together? Yes. Some teams use Postmark for one-way high-volume outbound notifications and AgentMail for agents that need full inbox capabilities. The two cover different parts of the email surface.

Is AgentMail SOC 2 compliant? Yes, SOC 2 Type II.

Does AgentMail offer inbound filtering? Yes. Allowlists and blocklists can be configured per inbox to filter senders before they reach the agent.

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.