Integration
MCP for Postmark: Claude, auditing your transactional mail.
You run transactional email on Postmark because it's fast and it lands. But the newsletter you bolted onto a broadcast stream has started drawing spam complaints, the bounce rate crept up after the last product launch, and you half-suspect someone's been sending bulk mail out of the transactional stream where it poisons your best reputation. So you open five tabs — Message Streams, Bounces, Suppressions, Sender Signatures, the Stats page — and start reconciling by eye. Ask Claude for help and it gives you good advice about all of it. Generic advice. It has never seen your streams, your bounce feed, or last week's complaint rate. An MCP for Postmark — a way to hand Claude a token instead of general knowledge — is what closes that gap. Claude stops describing the audit and starts running it against your real account.
What "MCP" actually means here.
MCP stands for Model Context Protocol, an open standard from Anthropic that lets Claude reach outside the chat window. Think of it as a plugin system, except the plugins don't add small features — they give Claude entirely new capabilities: tools that read your data and build real artifacts. Orbit is one such MCP, built for lifecycle and deliverability work. Install it, connect a Postmark token, and Claude gains the ability to read your account — and, if you turn it on, write to it. Orbit is not an official Postmark product; it's an independent MCP that calls Postmark's public API with the token you provide, and nothing leaves your machine except the calls to Postmark you configured. The full walk-through of what an MCP is and how it changes the work lives on the MCP for marketing page →.
What Orbit does with Postmark today.
No hand-waving. Postmark's API is clean and developer-first, so most of this is fully native. Where there's a limit, it's named — and we're careful to separate three different things: what Postmark's API genuinely allows, what Orbit simply hasn't built yet, and what Orbit holds back on purpose because it's read-only-first and the action is a high-consequence write.
Check the connection and name the server
Works todayA Postmark Server token maps to one server. Orbit calls the server endpoint to confirm the token is live and shows you which server it's for and which message streams — transactional, broadcast, inbound — sit under it, so there's no guessing about what the audit is pointed at.
Read message streams
Works todayThe full stream split on a server — the transactional stream for one-to-one mail, the broadcast stream for bulk, and inbound. This is the raw material for stream hygiene: spotting bulk sends going out on a transactional stream where they don't belong.
Read outbound messages and events
Works todayThe Messages API — outbound messages with their delivery, open, and click events. Claude can trace what actually happened to a given send rather than reasoning from a dashboard summary.
Read bounces
Works todayThe Bounces API — every bounce with its type (hard, soft, spam complaint, transient) and the raw SMTP detail behind it. This is the first place a deliverability problem shows up, and it reads natively.
Read suppressions
Works todayBroadcast-stream suppressions — who is suppressed and why (hard bounce, spam complaint, manual, or unsubscribe). Read against your send volume, a suppression list tells Claude whether the problem is list hygiene or something upstream.
Read sender signatures and DKIM
Works todayThe Sender Signatures API via your Account token — DKIM status, Return-Path verification, and the confirmed state of each signing domain. Claude can tell you which signatures are green and which are still pending in DNS.
Pull stats
Works todayThe Stats API — sends, bounce rate, spam-complaint rate, tracked opens and clicks, aggregated by day. The numbers a transactional deliverability review is actually made of.
Reactivate a bounce or clear a suppression
Partial — named limitPostmark's API supports reactivating a bounced recipient and deleting a broadcast-stream suppression, and Orbit can drive both. But each changes who your mail can reach, so it's a write held behind an explicit switch — read-only-first means the audit flags what to fix and you decide when to fix it.
Send a test message
Partial — named limitPostmark ships a dedicated test token that accepts a send, runs full validation, and returns success without delivering. Orbit validates against it by default and only fires a real message to your own address through your live Server token when you ask and the send tool is on.
Trigger a broadcast send
Held back by designReading broadcast streams and their suppressions works today. Actually firing a broadcast to a list is a high-consequence write Orbit holds back from by default — read-only-first means bulk sends stay in your hands, in Postmark, on purpose. Not an API dead-end, a deliberate line.
The short version: with a token in read-only-first mode, Orbit can audit your entire Postmark deliverability picture — streams, bounces, suppressions, sender signatures, stats — and tell you what's wrong. Turn on the write tools and it'll reactivate a bounce or clear a suppression on your say-so. The one line it won't cross without you asking is firing a broadcast: that stays yours.
The transactional audit it was built for.
This is where a Postmark token earns its place. Point Orbit at your account and ask Claude to run the checks a deliverability owner does by hand every quarter — except it reads the real state instead of asking you to describe it.
- Stream hygiene — transactional vs broadcast. Postmark keeps transactional and broadcast mail on separate
Message Streamsprecisely so a bulk send can't drag down the reputation that gets your receipts and password resets to the inbox. Orbit reads the streams on your server and flags the classic mistake — bulk or newsletter mail going out on the transactional stream — before it costs you inbox placement on the mail that actually matters. - Bounce and suppression review. Orbit sizes your hard bounces, soft bounces, and spam complaints against your send volume, and reads your broadcast-stream suppressions alongside them, so a rising complaint rate or a suppression list swallowing good addresses surfaces as a number, not a hunch — and it separates list-hygiene problems from authentication problems, which look the same from the inbox but need different fixes.
- Sender signatures, DKIM, and DMARC. Orbit reads Postmark's view of which sender signatures are confirmed and which DKIM and Return-Path records are still pending in DNS. DMARC isn't in Postmark's API — it lives in your DNS as a
_dmarcTXT record — so Claude reasons about your policy (p=none,quarantine, orreject) from the record itself and tells you whether your Postmark signing aligns with it.
None of this needs the write tools. The whole audit runs with Orbit in read-only-first mode — which is exactly how you should start.
How to connect it.
One or two tokens, depending on how wide you want the audit. In Postmark, tokens live in two places — and it's worth knowing the difference before you paste anything into Orbit's config.
- Server API token — scoped to one server.Found under your server's API Tokens tab. It reads that server's streams, messages, bounces, suppressions, and stats, and it can send. Postmark tokens aren't permission-scoped, so this token isn't physically read-only — which is why Orbit enforces read-only-first in its own config, keeping the send and mutate tools off until you switch them on.
- Account API token — for the account-wide pieces.Found under Account → API Tokens. It's what Orbit uses to read sender signatures, domains, and account-level suppressions across servers. Broader reach, so hand it over only when you want the cross-server view — and it's audited read-only-first just the same.
Each token is stored as a secret and never leaves your machine in plain text. That's the whole setup — no OAuth dance, no app to install on Postmark's side. If a tool needs a token you haven't connected, Orbit tells you which one to add rather than failing silently.
What's deepest on Braze — and why we say so.
Orbit works with every major ESP, but its deepest single-platform integration is Braze. A handful of Orbit's tools are built around concepts that only exist in Braze — Canvas flows, Content Blocks, its media library — and those stay Braze-named on purpose. Faking a Postmark equivalent would just be a worse version of a thing Postmark's model doesn't have.
For Postmark, that trade barely bites: the portable work — auditing deliverability, reading the streams, reviewing bounces and signatures, running the numbers — is exactly what a Postmark-based developer or deliverability owner needs. And if you later graduate to a lifecycle-native platform, the tooling and the discipline travel with you.
The half that isn't about the API at all.
Reading and writing Postmark is the connection. The reason to bother is everything Claude does once it's connected. Orbit ships 79 lifecycle skills — structured protocols for the actual jobs: auditing deliverability, composing an email, laddering a win-back, scoring a subject line. Those are ESP-agnostic; they work the same whether the account underneath is Postmark or anything else.
Underneath sit 130 tools — an MJML pipeline that compiles to clean, dark-mode-safe HTML, a render-and-QA gate that catches the clipping and inbox breakage before you send, and the calculators a real test needs: sample size, holdout, replenishment timing. Postmark gives you the send and the deliverability rails. Orbit is the practitioner sitting next to them, reading the same dashboards you do.
Is this for you?
This is for the developer or deliverability owner who runs Postmark and wants a straight read on it — the person watching the bounce feed, keeping the streams clean, and making sure the sender signatures stay confirmed. If that's your week, Orbit hands you a Claude that reads the real state through a token you control. It's a weaker fit if you want a hands-off tool that runs the program while you watch a dashboard. Orbit doesn't run your program, and it won't fire your broadcasts. You do. It just gives you a Claude that works like a deliverability practitioner instead of a search engine — and a straight answer about what your ESP can and can't do, which is rarer than it should be.
Try it.
Orbit is free — every skill and tool included, no seats and no subscription. Paste a Postmark Server token, keep it read-only-first, and Claude goes from advisor to deliverability audit the same afternoon.
Run a different ESP?
The same honest treatment, per platform:
Frequently asked.
What is an MCP for Postmark?
An MCP — Model Context Protocol, an open standard from Anthropic — gives Claude real tools instead of general knowledge. Connected to Postmark through Orbit with your own token, Claude can read your message streams, bounces, suppressions, sender-signature and DKIM status, and delivery stats — rather than describing what you should do and leaving the doing to you. It is not an official Postmark product; it is an independent MCP that calls Postmark's public API with the token you provide.
Can I connect Postmark with a read-only token?
Not at the token — and that's the honest wrinkle. Unlike SendGrid, Postmark's Server API tokens aren't permission-scoped: a Server token can read and send within its server, and there's no read-only variant to hand over. So Orbit enforces read-only-first in its own config instead — the send and mutate tools stay off until you switch them on, and every audit on this page runs without them. For cross-server work — sender signatures, domains, account-wide suppressions — you point Orbit at your Account API token, which is broader but still audited read-only-first.
What can Orbit read for a transactional deliverability audit?
The pieces a real audit is made of. Orbit reads your message streams — the transactional, broadcast, and inbound split — so Claude can see whether bulk mail is going out on a transactional stream where it doesn't belong. It reads your bounces through the Bounces API — hard bounces, soft bounces, and spam complaints with the raw SMTP detail — and your broadcast-stream suppressions, so a rising bounce or complaint rate surfaces as a number, not a hunch. Sender signatures come back too — DKIM status and Return-Path verification per signing domain. And it pulls the Stats API — sends, bounce rate, spam-complaint rate, opens, and clicks, aggregated by day. DMARC lives in your DNS rather than Postmark's API, so Orbit reasons about your policy from the record itself.
Can Orbit clean up bounces and suppressions?
It can, if you turn the write tools on. Postmark's API lets you reactivate a bounced recipient and delete a suppression from a broadcast stream, and Orbit can drive both — but each is a mutation that changes who your mail can reach, so it stays behind an explicit switch. Read-only-first means the audit tells you which suppressions look like list-hygiene noise and which are genuine hard bounces, and you decide what to reactivate. Orbit reads the whole picture first; it only writes when you ask it to.
Can Orbit send a test message through Postmark?
Yes, and Postmark has the cleanest test path in the category. It ships a dedicated test token — POSTMARK_API_TEST — that accepts a send, runs the full validation, and returns success without delivering anything. So Orbit validates against the test token by default, proving a payload is well-formed with nothing ever leaving Postmark. It only fires a genuine message to your own address through your live Server token when you ask for it and the send tool is on. Alongside that, Orbit runs its own local QA gate on the HTML — dark mode, clip length, accessibility — which needs no send at all.
Is Postmark the right home for a serious lifecycle program?
Postmark is strongest as a transactional-email engine — the layer that gets receipts, password resets, and notifications to the inbox fast, with a reputation kept clean by separating transactional and broadcast streams. Its broadcast streams handle bulk and newsletter sending with proper suppression and unsubscribe management, which covers a lot of SMB lifecycle work. Where it strains is deep, branching, behaviour-driven journeys and true incrementality testing across a large audience; if that's the week you're living in, a lifecycle-native platform like Braze is the graduation. Orbit works with both, deepest on Braze — so the tooling and the discipline travel with you if you move.