Menu

Mattering Automations Postmark integration

Connect Postmark to Mattering Automations: transactional and template sending, bulk broadcast, message search, statistics, bounces and suppressions, message streams, webhooks and inbound rules, plus account-level administration of servers, domains and sender signatures, as steps in a visual workflow.

The Mattering Automations Postmark integration puts Postmark's REST API on your automation canvas: send a single message, a batch, a template render or an asynchronous bulk broadcast; search outbound and inbound mail and read a message's full delivery event timeline or its raw MIME source; pull a sending overview and eleven daily statistics breakdowns; work bounces, reactivations and per-stream suppressions; create, edit, archive and unarchive message streams; manage webhooks and inbound blocking rules; and administer servers, sending domains and sender signatures. Eighty seven nodes in total, forty four that read and forty three that act.

One detail decides whether your setup goes smoothly, so it is first rather than buried. Postmark authenticates with two different, non-interchangeable tokens. A server token covers sending, messages, statistics, bounces, templates, message streams, suppressions, webhooks and inbound rules, which is 62 of the nodes. An account token covers servers, domains, sender signatures, pushing templates between servers and data removal, which is the other 25. Both pages in Postmark are called API Tokens, one on the server and one on the account, and mixing them up is the most common way this connection goes wrong. The account token is optional here: leave it blank and the 62 server-level nodes work normally, while the 25 that need it stop before making a request and name the token rather than returning a 401.

The second thing worth reading before you build is the message stream model. Postmark keeps Transactional, Broadcast and Inbound as separate streams so bulk mail cannot damage the deliverability of receipts and password resets, and its send endpoint defaults to the reserved transactional stream when none is given. So Postmark: Send Bulk Broadcast requires a Broadcast stream, offers only Broadcast streams in its picker, refuses the reserved transactional id by name, and reads the stream back to confirm its type before sending. There is no override. Everything below explains the setup in full, and the guide ends with the complete node reference.

Before you start

  • A Postmark account. New accounts start on Postmark's free developer plan, which offers 100 emails per month to test an integration with, which Postmark states never expires or runs out, and which includes the REST API, SMTP and Sandbox Mode. That is enough to set this integration up and verify it properly.
  • A Postmark server, and a decision about which one this connection represents. A server is Postmark's isolation boundary: its own API tokens, its own message streams, its own templates, its own webhooks and its own statistics. A connection is scoped to one server, so staging and production are two connections rather than one with a switch.
  • The server API token for that server, from its API Tokens tab in Postmark.
  • A Broadcast message stream on that server, and its id. The connection test checks it, and it must be a stream whose type Postmark reports as Broadcasts. If the server has only the default transactional stream, create a Broadcast stream in Postmark or with Postmark: Create Message Stream before testing.
  • The account API token, but only if you intend to use the 25 account-level nodes: Postmark: List Servers, Postmark: List Domains, Postmark: List Sender Signatures and their siblings, Postmark: Push Templates Between Servers, and the two data removal nodes. It is on your Postmark account's own API Tokens page, which is a different page from the server's. Postmark's API overview describes it as available to account owners and admins, so on a restricted account somebody with owner access has to fetch it. Leave it blank otherwise.
  • Access to your sending domain's DNS, if you plan to use the domain nodes. DKIM and Return-Path verification both require publishing records that Postmark gives you and then asking Postmark to re-check them.
  • A Mattering workspace with access to the Automations app.

Collect your Postmark tokens

There is no OAuth flow here: Postmark authenticates with tokens you copy out of its interface and paste into Mattering. The part that trips people up is that Postmark has two of them, on two different pages that share a name, and they are not interchangeable. Collect the server token always, and the account token only if you need the account-level nodes.

Sign in to Postmark and open the server this connection should represent. Open its API Tokens tab and copy the server API token. This is the token that covers sending, message search, statistics, bounces, templates, message streams, suppressions, webhooks and inbound rules, and it is the one the connection test uses.
This is the SERVER token, not the account token. Both pages in Postmark are titled API Tokens: one belongs to a server, the other to your account. Pasting the account token into the server token field produces a 401 at Test Connection that reads exactly like a mistyped token.
Open Message Streams on the same server and note the id of the Broadcast stream campaign mail should go out on. If there is only a transactional stream, create a Broadcast one first. The stream type is chosen at creation, and Postmark's edit endpoint changes only the name, description and unsubscribe handling, so the type you pick is the type you keep.
Only if you need the account-level nodes: open your Postmark Account settings and its own API Tokens page, and copy the account API token. It covers servers, domains, sender signatures, template push and data removal. Skip this step entirely if you are not administering those things.
Leaving the account token blank is a supported setup, not a half-finished one. The 62 server-level nodes never look at it. The 25 that need it refuse before making any request and return a message naming the token, the page it is on, and which nodes do and do not need it, so a blank account token never surfaces as a confusing 401.
Want somewhere safe to exercise the send nodes? Set a server's delivery type to Sandbox in Postmark, or with Postmark: Update Server. A sandbox server accepts mail and discards it, so nothing reaches a real inbox and nothing is spent from the monthly allowance. Remember to turn it off: a production server left on Sandbox accepts every send and delivers none of it.

Connect Postmark to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Postmark from the list, then click Create new credential.
Paste the server API token into Server API token and the Broadcast stream id into Broadcast message stream. Paste the account token into Account API token if you collected one, and leave it blank if you did not.
The fourth field, Inbound webhook secret, is only for reply capture on campaign sending and is unrelated to the 87 nodes in this reference. Leave it blank unless you are capturing replies.
Save the credential. Tokens are stored encrypted in Google Secret Manager and never appear in workflow logs or node output.
Click Test Connection. Mattering reads the server with the server token, then reads the message stream you named and confirms Postmark reports its type as Broadcasts. A pass therefore proves the token and the stream together, which is deliberate: a test that only checked the token would happily bless a transactional stream and you would not find out until campaign mail started competing with your password resets for reputation.
All 87 Postmark nodes appear in your canvas palette.

Verify it works

Open any automation canvas, find the Postmark section of the palette and drop Postmark: Get Server onto it, then run a test step. It takes no parameters, spends no email allowance and returns the server this credential belongs to, including its inbound address, its webhook URLs and its tracking defaults. If this returns 200, the server token and the header wiring are both correct. Treat the output with care: Postmark returns the server's API tokens in this response.

Now run Postmark: List Message Streams. This is the read that orients everything else, because it shows every stream on the server with the type Postmark assigns it: Transactional, Broadcasts or Inbound. Confirm the id you put in Broadcast message stream appears here with a type of Broadcasts. If it does not, the connection test would already have told you, but this is where you see why.

Open a node with a stream picker, such as Postmark: Send Bulk Broadcast, and look at the Message stream field. It should list your Broadcast streams with the stream type as a second line under each name, and it should not offer the transactional stream at all. That picker is pinned to Broadcast streams, which is the visible half of the guard described below.

If you added an account token, run Postmark: List Servers as well. It is the cheapest account-level read and it proves the second token independently of the first. If you did not add one, run it anyway once: instead of an opaque failure you should get a message telling you the account token is missing and which page of Postmark it is on. That is the intended behaviour, and confirming it now means you will recognise it later. Everything in this verify path is read-only and sends no mail, so it is safe to re-run whenever you want to check the connection.

Node reference

87 nodes, generated from the connector itself so this reference always matches what ships.

Read and query nodes 44

Postmark: Get Bounce

postmark_get_bounce

Read one bounce in detail, including the receiving server's own explanation and whether the address can be reactivated.

Postmark: Get Bounce Counts

postmark_get_bounce_counts

Daily bounce counts split by kind: hard bounces, soft bounces, transient delays and SMTP API errors. Days with no bounces of a kind simply omit that key.

Postmark: Get Bounce Source

postmark_get_bounce_dump

Get the raw SMTP conversation for a bounce. Postmark keeps bounce dumps for 30 days, so older bounces return nothing.

Postmark: Get Bulk Request

postmark_get_bulk_request

Read one bulk send request's status, percentage complete, released count and failed count.

Postmark: Get Click Browser Usage

postmark_get_click_browser_families

Daily clicks broken down by browser family. Browser names vary by account and by window, so the columns are not a fixed set.

Postmark: Get Click Counts

postmark_get_click_counts

Daily link click counts, total and unique. As with opens, totals add across days and uniques do not.

Postmark: Get Click Location

postmark_get_click_location

Daily clicks split by where in the message the link was clicked, HTML part or text part.

Postmark: Get Click Platform Usage

postmark_get_click_platforms

Daily clicks split by platform: desktop, mobile and unknown.

Postmark: Get Clicks For Message

postmark_get_message_clicks

List every recorded link click for one specific message.

Postmark: Get Data Removal Status

postmark_get_data_removal

Check whether a data removal request is still pending or has completed. A status of Done means the erasure has happened and cannot be undone. Needs the account token.

Postmark: Get Delivery Stats

postmark_get_delivery_stats

Lifetime bounce totals by type for this server, plus the number of addresses currently deactivated because of bounces.

Postmark: Get Domain

postmark_get_domain

Read one domain in full, including the exact DNS records to publish for DKIM and Return-Path. Needs the account token.

Postmark: Get Email Client Usage

postmark_get_email_client_usage

Daily opens broken down by email client. Client names are whatever Postmark detected for your recipients, so the columns differ between accounts and between windows.

Postmark: Get Inbound Message

postmark_get_inbound_message

Read one received message in full, including bodies, every header, attachment metadata and, when it was blocked, the rule that blocked it.

Postmark: Get Message Stream

postmark_get_message_stream

Read one message stream, including its type and its unsubscribe handling.

Postmark: Get Open Counts

postmark_get_open_counts

Daily open counts, total and unique. Totals add up across days but uniques do not: one recipient opening on Monday and Tuesday is one unique over the week, not two.

Postmark: Get Open Platform Usage

postmark_get_open_platforms

Daily opens split by platform: desktop, mobile, webmail and unknown.

Postmark: Get Opens For Message

postmark_get_message_opens

List every recorded open for one specific message.

Postmark: Get Outbound Message

postmark_get_outbound_message

Read one sent message in full, including its bodies, metadata and the whole event timeline of deliveries, transient failures, opens, clicks, bounces and subscription changes.

Postmark: Get Outbound Message Source

postmark_get_outbound_message_dump

Get the raw MIME source of a sent message, headers and all. Useful when a recipient's mail server disputes what was actually delivered.

Postmark: Get Sender Signature

postmark_get_sender_signature

Read one sender signature, including its confirmation state and its DKIM and Return-Path records. Needs the account token.

Postmark: Get Sending Overview

postmark_get_outbound_overview

One summary of sending health over a window: sent, bounced, spam complaints, opens, tracked mail and clicks, plus bounce and complaint rates. The rates are percentages of sent and must never be added across windows.

Postmark: Get Sent Counts

postmark_get_sent_counts

Daily counts of messages sent, with the window total alongside them.

Postmark: Get Server

postmark_get_server

Read the configuration of the server this credential belongs to, including its inbound address, webhook URLs and tracking defaults. API tokens are returned by Postmark and should be treated as secrets.

Postmark: Get Server By ID

postmark_get_server_by_id

Read any server on the account by ID. Needs the account token.

Postmark: Get Spam Complaint Counts

postmark_get_spam_counts

Daily counts of spam complaints. A rising line here is the earliest reliable warning that a sending reputation is in trouble.

Postmark: Get Template

postmark_get_template

Read one template's subject, HTML body, text body and layout by ID or alias.

Postmark: Get Tracked Email Counts

postmark_get_tracked_counts

Daily counts of messages sent with tracking enabled. This is the denominator for any honest open or click rate.

Postmark: Get Webhook

postmark_get_webhook

Read one webhook's URL, authentication, custom headers and event triggers.

Postmark: Get Webhook Statistics

postmark_get_webhook_statistics

Delivery health for one webhook over Postmark's own fixed trailing 24 hours: request counts, success rate, retries and response times, overall and per trigger. The window is not selectable.

Postmark: List Bounces

postmark_list_bounces

List bounces on this server, filterable by bounce type, address, tag, message, stream and date window. The Inactive flag tells you whether Postmark has stopped sending to that address.

Postmark: List Bulk Requests

postmark_list_bulk_requests

List recent bulk send requests on this server with their progress, released counts and failure counts.

Postmark: List Domains

postmark_list_domains

List the sending domains on the account with their SPF, DKIM and Return-Path verification status. Needs the account token.

Postmark: List Inbound Rules

postmark_list_inbound_rules

List the addresses and domains blocked from delivering inbound mail to this server.

Postmark: List Message Clicks

postmark_list_message_clicks

List link click events across the server, including which link was clicked and whether it was clicked in the HTML or the text part. Link tracking must be enabled for events to exist.

Postmark: List Message Opens

postmark_list_message_opens

List open events across the server with the client, operating system, platform and approximate location recorded for each. Open tracking must be enabled for events to exist.

Postmark: List Message Streams

postmark_list_message_streams

List the message streams on this server with their types. Transactional, Broadcast and Inbound are separate streams and the type decides what a stream may legitimately carry, so this is the list to check before sending anything.

Postmark: List Sender Signatures

postmark_list_sender_signatures

List the confirmed and pending From addresses on the account. Needs the account token.

Postmark: List Servers

postmark_list_servers

List every server on the Postmark account. Needs the account token, which is a different token from the server token used for sending.

Postmark: List Suppressions

postmark_dump_suppressions

List the suppressed addresses on one message stream, with why each was suppressed and who suppressed it. Suppressions are per stream, so an address blocked on your broadcast stream may still receive transactional mail.

Postmark: List Templates

postmark_list_templates

List the templates and layouts on this server. A server holds at most 100 templates.

Postmark: List Webhooks

postmark_list_webhooks

List the webhooks configured on this server, with their URLs, verification status and which events each one is subscribed to.

Postmark: Search Inbound Messages

postmark_search_inbound_messages

Search messages received on the inbound stream. Note the default status filter is processed, so blocked and failed inbound mail does not appear until you ask for it by status.

Postmark: Search Outbound Messages

postmark_search_outbound_messages

Search sent messages by recipient, sender, tag, subject, status, stream or date window. Use extra_query to filter on a metadata value, for example metadata_order-id.

Action nodes 43

Postmark: Archive Message Stream

postmark_archive_message_stream

Archive a message stream. Sending on it stops immediately, and Postmark purges it permanently on the returned ExpectedPurgeDate. Unarchive it before that date if this was a mistake; after the purge the stream and its data are gone.

Postmark: Bypass Inbound Block

postmark_bypass_inbound_message

Release a blocked inbound message so Postmark delivers it to your inbound webhook after all. Only works on messages whose status is blocked.

Postmark: Create Domain

postmark_create_domain

Add a sending domain and get back the DNS records to publish. A custom Return-Path must be a subdomain of the From domain. Needs the account token.

Postmark: Create Inbound Rule

postmark_create_inbound_rule

Block an address or a whole domain from delivering inbound mail. Blocking a domain silently stops every sender on it, so check the value before saving.

Postmark: Create Message Stream

postmark_create_message_stream

Create a message stream. The type is fixed at creation and cannot be changed later, and Broadcast streams require unsubscribe management, so choose deliberately rather than reusing a transactional stream for campaigns.

Postmark: Create Sender Signature

postmark_create_sender_signature

Add a From address. Postmark emails that address a confirmation link and the signature cannot send until someone clicks it, so the mailbox has to be one a person actually reads. Needs the account token.

Postmark: Create Server

postmark_create_server

Create a server, which is Postmark's isolation boundary: its own API token, its own streams, its own statistics and its own sender configuration. Needs the account token.

Postmark: Create Template

postmark_create_template

Create a template or a layout on this server. Give it an alias so sends can reference it by a stable name instead of a numeric ID.

Postmark: Create Webhook

postmark_create_webhook

Create a webhook for delivery, bounce, open, click, spam complaint or subscription change events. Postmark verifies the endpoint before saving unless you turn that off, and it does not sign payloads, so protect the endpoint with HTTP basic auth or a secret in the URL.

Postmark: Delete Domain

postmark_delete_domain

Delete a sending domain. Every sender signature on it stops being able to send, and the domain must be added and verified again from scratch to recover. Needs the account token.

Postmark: Delete Inbound Rule

postmark_delete_inbound_rule

Remove an inbound block, so mail from that address or domain is accepted again.

Postmark: Delete Sender Signature

postmark_delete_sender_signature

Delete a sender signature. Anything still sending from that address starts failing immediately, and re-adding it means going through email confirmation again. Needs the account token.

Postmark: Delete Server

postmark_delete_server

Delete a server and everything scoped to it: its API tokens, message streams, templates, webhooks and message history. This cannot be undone, and Postmark does not enable it on every account. Needs the account token.

Postmark: Delete Template

postmark_delete_template

Delete a template. Any automation still sending with this alias or ID starts failing immediately, and Postmark documents no way to restore it.

Postmark: Delete Webhook

postmark_delete_webhook

Delete a webhook. Events stop being delivered immediately and are not replayed once a new webhook is created, so anything that fires in the gap is lost.

Postmark: Push Templates Between Servers

postmark_push_templates

Copy templates from one server to another, matching on alias. Run it first with PerformChanges false to see exactly which templates would be created or overwritten. Needs the account token.

Postmark: Reactivate Bounced Address

postmark_activate_bounce

Reactivate an address Postmark deactivated after a bounce, so sending to it resumes. Only do this when you know the underlying mailbox problem is fixed; repeatedly reactivating a dead address damages your sending reputation.

Postmark: Remove Suppressions

postmark_delete_suppressions

Remove addresses from a stream's suppression list so sending to them resumes. Spam complaint suppressions cannot be removed, by design, and those entries come back with a Failed status.

Postmark: Request Data Removal

postmark_create_data_removal

Erase a recipient's data from the Postmark account, for GDPR and CCPA subject requests. This is irreversible: once the request completes, that recipient's message history, event data and content are permanently gone and Postmark offers no way to recover any of it. Access to this endpoint is granted by Postmark support on request. Needs the account token.

Postmark: Request New Sender DKIM

postmark_request_sender_dkim

Request a new DKIM key for a sender signature. Postmark has deprecated this endpoint in favour of rotating DKIM on the domain, and returns an error if a renewal is already in progress. Needs the account token.

Postmark: Resend Sender Confirmation

postmark_resend_sender_confirmation

Send the confirmation email for a pending sender signature again. Needs the account token.

Postmark: Retry Inbound Message

postmark_retry_inbound_message

Requeue an inbound message whose webhook delivery failed. Fix the endpoint first, otherwise it fails again.

Postmark: Rotate Domain DKIM Key

postmark_rotate_domain_dkim

Generate a new DKIM key pair for the domain. The new record appears as pending and must be published in DNS and verified before the old key can be safely removed; removing the old record early breaks signing. Needs the account token.

Postmark: Send Bulk Broadcast

postmark_send_bulk

Queue a bulk broadcast to many recipients from one shared body or template. Postmark keeps broadcast and transactional traffic apart on purpose, so this node requires a Broadcast message stream and refuses to run against a transactional one. The send is accepted and processed asynchronously, so check the bulk request status for the outcome.

Postmark: Send Email

postmark_send_message

Send one email with Postmark's own request shape, exposing every provider field: attachments, inline images, custom headers, metadata and per-message tracking. This is the raw passthrough send. For campaign sending use Postmark: Send Campaign Email, which keeps the same parameters across every email provider.

Postmark: Send Email Batch

postmark_send_batch

Send up to 500 individually addressed emails in one call. Each message is validated and delivered independently, so the response is a per-message list and a partial failure is normal: check every entry's ErrorCode, not just the HTTP status.

Postmark: Send Email With Template

postmark_send_with_template

Send one email rendered from a stored template, supplying the values its placeholders need. Provide TemplateAlias or TemplateId, never both.

Postmark: Send Template Batch

postmark_send_batch_with_templates

Send up to 500 template-rendered emails in one call, each with its own template and its own model. Results come back per message, so a partial failure is normal and every entry's ErrorCode needs checking.

Postmark: Suppress Addresses

postmark_create_suppressions

Add addresses to one stream's suppression list so Postmark stops sending to them. Results come back per address, so check each Status rather than assuming a 200 means all of them took.

Postmark: Unarchive Message Stream

postmark_unarchive_message_stream

Restore an archived message stream, provided its purge date has not passed.

Postmark: Update Domain

postmark_update_domain

Change a domain's custom Return-Path. It must be a subdomain of the From domain and needs its own CNAME record. Needs the account token.

Postmark: Update Message Stream

postmark_update_message_stream

Rename a stream, change its description or change how unsubscribes are handled. The stream type itself is not editable.

Postmark: Update Sender Signature

postmark_update_sender_signature

Update a signature's display name, Reply-To or Return-Path. The From address itself cannot be changed; create a new signature instead. Needs the account token.

Postmark: Update Server

postmark_update_server

Update the server this credential belongs to. Switching DeliveryType to Sandbox makes the server accept mail and silently discard it, which is useful for testing and damaging if left on by mistake.

Postmark: Update Server By ID

postmark_update_server_by_id

Update any server on the account by ID. Needs the account token. Switching DeliveryType to Sandbox makes that server accept mail and discard it.

Postmark: Update Template

postmark_update_template

Update a template's name, subject, bodies, alias or layout. The change applies to every future send that references it.

Postmark: Update Webhook

postmark_update_webhook

Change a webhook's URL, authentication, headers or which events it receives.

Postmark: Validate Template

postmark_validate_template

Render template content against a test model without saving or sending anything, and get back the rendered output plus any syntax errors with line numbers.

Postmark: Verify Domain DKIM

postmark_verify_domain_dkim

Ask Postmark to re-check the domain's DKIM DNS record and update its verification status. Run this after publishing the record. Needs the account token.

Postmark: Verify Domain Return-Path

postmark_verify_domain_return_path

Ask Postmark to re-check the domain's custom Return-Path CNAME and update its verification status. Needs the account token.

Postmark: Verify Domain SPF

postmark_verify_domain_spf

Re-check the domain's SPF record. Postmark has deprecated this endpoint because SPF is no longer required for its own sending; prefer DKIM and Return-Path verification. Needs the account token.

Postmark: Verify Sender Signature SPF

postmark_verify_sender_spf

Re-check the SPF record behind a sender signature. Postmark has deprecated this endpoint; prefer DKIM and Return-Path verification on the domain. Needs the account token.

Postmark: Verify Webhook

postmark_verify_webhook

Make Postmark post a test payload for each subscribed trigger and report the status code your endpoint returned for each one.

Using the integration

Two tokens, and which nodes need which

Postmark authenticates server-level and account-level requests with two different headers, X-Postmark-Server-Token and X-Postmark-Account-Token, and a request signed with the wrong one is rejected. Sixty two nodes are server level: sending, messages, statistics, bounces, templates other than push, message streams, suppressions, webhooks, inbound rules and the server behind the credential. Twenty five are account level: Postmark: List Servers and the rest of the servers section, the domains section, the sender signatures section, Postmark: Push Templates Between Servers, and the two data removal nodes. Template push is the one that catches people, because it sits on the templates page in Postmark's own documentation where everything else is server scoped. Each node that needs the account token says so at the end of its description. When the account token is blank, those nodes refuse before the request is made and return a message that names the token and the page it lives on rather than sending a server token and letting Postmark answer with a bare 401. The account-level pickers behave the same way: Postmark: List Servers, Postmark: List Domains and Postmark: List Sender Signatures feed the server, domain and signature pickers on other nodes, so without an account token you see that explanation in the config panel rather than an empty dropdown.

Message streams, and why bulk sending is constrained

Postmark's product thesis is that Transactional, Broadcast and Inbound belong on separate streams, because bulk mail sent down a transactional stream damages the deliverability of receipts, password resets and order confirmations, and that damage is silent until it is expensive. Postmark's own send endpoint defaults to the reserved transactional stream when no stream is given, so the failure is one forgotten field away. This integration removes that possibility on the node where it matters rather than warning about it. On Postmark: Send Bulk Broadcast the stream is required with no fallback to the server default, the picker is pinned so that only Broadcast streams are offered, the reserved transactional id is rejected by name before any network call, and the stream you chose is read back with a single request and refused unless Postmark reports its type as Broadcasts. There is deliberately no override flag: an escape hatch here would be the mistake wearing a checkbox. The guard costs one cheap read, on the one operation where an extra round trip is irrelevant. Everywhere else the stream is a picker rather than a free-text box, and each option carries the stream type as a second line, because two streams both named Newsletter are ambiguous at exactly the moment the choice matters. Postmark: Create Message Stream carries the rule that outlives the click: the type is set at creation and Postmark's edit endpoint changes only name, description and unsubscribe handling.

Sending: which node for which job

There are five send paths and they are not interchangeable. Postmark: Send Email is the provider-shaped single send, exposing every Postmark field: attachments, inline images, custom headers, metadata and per-message tracking. Postmark: Send Email With Template renders a stored template by alias or id, supplying the values its placeholders need, and takes one or the other rather than both. Postmark: Send Email Batch and Postmark: Send Template Batch each accept up to 500 individually addressed messages in one call, within a 50 MB payload; every message is validated and delivered independently, so a partial failure is normal and the response is a per-message list whose ErrorCode entries need checking rather than just the HTTP status. Postmark: Send Bulk Broadcast is the broadcast path: one shared body or template to many recipients, processed asynchronously, returning a request id that Postmark: Get Bulk Request then reports status, percentage complete, released count and failed count against. Separately from all five, the connector unlocks the shared campaign send node postmark_send_email, which keeps one uniform contract across email providers so campaign sending in other Mattering apps does not branch on which provider a workspace uses.

Statistics, and the arithmetic that goes wrong

Postmark: Get Sending Overview summarises a window in one call: sent, bounced, spam complaints, tracked mail, opens and clicks, with the bounce and complaint rates alongside. Eleven daily breakdowns sit under it, including Postmark: Get Sent Counts, Postmark: Get Bounce Counts, Postmark: Get Spam Complaint Counts, Postmark: Get Open Counts, Postmark: Get Click Counts and Postmark: Get Tracked Email Counts. Three rules keep the numbers honest. Rates are percentages of sent, so bounce rate and complaint rate must never be added across days or windows; weight them by sent or recompute them from the counts. Unique figures cannot be recombined either: one recipient opening on Monday and again on Tuesday is one unique over the pair, not two, so a weekly unique cannot be rebuilt from daily uniques. And Postmark: Get Email Client Usage and Postmark: Get Click Browser Usage return columns named for whatever Postmark detected for your recipients in that window, so the column set is open and differs between accounts and between windows, which makes them fine to display and unsafe to aggregate blindly. Postmark: Get Tracked Email Counts is the denominator for any honest open or click rate, since untracked mail cannot produce either.

Dates are Eastern time, and data expires

Postmark evaluates the fromdate and todate filters on statistics, messages, bounces and suppressions in United States Eastern time rather than UTC. A window assembled from UTC dates is shifted by hours at both ends, which quietly moves rows between day buckets and produces a report that looks entirely plausible and is a few percent wrong at the edges. Every windowed date field in this integration says so in its own description. Retention is the other boundary. Postmark documents message retention as 45 days by default and configurable from 7 to 365 days, and message data expires at the end of it, so Postmark: Search Outbound Messages reaching past your retention period returns nothing rather than an error. Bounce dumps are shorter still: Postmark does not store them beyond 30 days, so Postmark: Get Bounce Source returns nothing for an older bounce even though Postmark: Get Bounce still describes it. And Postmark: Get Webhook Statistics reports on Postmark's own fixed trailing 24 hours, which cannot be filtered or widened.

Bounces and suppressions are different lists

A bounce is an event and a suppression is a state, and confusing them is why lists stay dirty. Postmark: List Bounces reads the events, filterable by type, address, tag, message, stream and date window, with an Inactive flag on each row telling you whether Postmark has stopped sending to that address. Postmark: Get Bounce adds the receiving server's own explanation and Postmark: Get Bounce Source the raw SMTP conversation. Postmark: Reactivate Bounced Address resumes sending to an address Postmark deactivated, which is right when a mailbox problem is genuinely fixed and damaging when it is used to keep hammering a dead address. Suppressions are per message stream rather than per server, which is the detail most people miss: an address suppressed on your broadcast stream can still receive transactional mail, and that is usually what you want. Postmark: List Suppressions dumps one stream's list with the reason and the origin, Postmark: Suppress Addresses adds to it and Postmark: Remove Suppressions takes entries off it. Both return a per-address result rather than a single verdict, so check each Status instead of assuming a 200 means every address took. One rule is absolute: Postmark documents that spam complaint suppressions cannot be deleted, so those entries come back Failed by design rather than by fault.

Managing Postmark's webhooks from a workflow

Postmark's webhooks are managed by these nodes rather than being Mattering triggers, and the distinction is worth being precise about. This connector has no trigger nodes, so a Postmark workflow runs on a schedule and reads. What the webhook nodes do is administer the webhooks Postmark posts to endpoints you own: Postmark: List Webhooks, Postmark: Create Webhook, Postmark: Update Webhook, Postmark: Delete Webhook, Postmark: Verify Webhook and Postmark: Get Webhook Statistics. Three behaviours matter when you automate them. Postmark verifies the endpoint against each enabled event when a webhook is created, every enabled event has to answer 200, and Postmark documents that an unverified webhook will not receive events until it passes verification, so a webhook created against an endpoint that is not live yet exists and delivers nothing. Postmark does not document signing its webhook payloads, but it does support HTTP basic auth credentials and custom headers on the webhook itself, which is how you keep an endpoint from accepting anything that finds it. And Postmark: Delete Webhook stops delivery immediately with no replay, so events that fire before a replacement is verified are simply gone.

Inbound mail, and the filter that hides the problems

Postmark: Search Inbound Messages reads what arrived on the inbound stream, and it has one trap the node names in its own description: Postmark defaults the status filter to processed, so blocked, failed, queued and scheduled mail is invisible until you ask for it by status. A weekly sweep for blocked and failed inbound mail is one of the more valuable things to automate here, because nobody notices mail that never arrived. Postmark: Get Inbound Message returns the full message with bodies, every header, attachment metadata and, where it was blocked, the rule that blocked it. Postmark: Bypass Inbound Block releases a legitimate message a rule caught, and works only on messages whose status is blocked. Postmark: Retry Inbound Message requeues one whose webhook delivery failed, which is worth doing only after the endpoint is fixed, since otherwise it fails again. The rules themselves are Postmark: List Inbound Rules, Postmark: Create Inbound Rule and Postmark: Delete Inbound Rule, and creating one deserves a second look before saving: a rule can block a whole domain, which silently stops every sender on it.

Account administration: servers, domains and signatures

These 25 nodes are the part most email integrations leave out, and they are where an unattended workflow earns its keep, because domain and signature state drifts quietly. Postmark: List Domains reports SPF, DKIM and Return-Path verification for every domain on the account in one call, which makes a weekly audit trivial. Postmark: Get Domain returns the exact DNS records to publish, Postmark: Verify Domain DKIM and Postmark: Verify Domain Return-Path ask Postmark to re-check them once they are live, and Postmark: Rotate Domain DKIM Key handles rotation, where the sequence is the whole risk: publish and verify the new record before removing the old one, because removing it early breaks signing. Two nodes here are Postmark's own deprecations rather than ours, and say so on their face: Postmark: Verify Domain SPF and Postmark: Verify Sender Signature SPF are documented by Postmark as no longer required for its sending, and Postmark: Request New Sender DKIM is superseded by rotating DKIM on the domain. They are included because an existing account may still need them, not because they are the current path. On the signatures side, Postmark: Create Sender Signature adds a From address that cannot send until somebody clicks a confirmation link Postmark emails to it, so use a mailbox a person actually reads, and Postmark: Resend Sender Confirmation chases it. Postmark: Push Templates Between Servers copies templates from one server to another matching on alias, and should be run first with PerformChanges set to false, which returns exactly what would be created or overwritten without doing it.

The eight destructive nodes

Eight nodes are classed destructive and each states its cost in its own description rather than relying on you to have read this page. Postmark: Request Data Removal erases a recipient's message history, event data and content from the account for a GDPR or CCPA subject request; Postmark documents no way to recover any of it, and Postmark makes the endpoint available by request through support rather than enabling it by default. Postmark: Get Data Removal Status is a safe read, but a status of Done means the erasure has already happened. Postmark: Delete Server removes a server and everything scoped to it, including its API tokens, streams, templates, webhooks and message history, and Postmark does not enable it on every account. Postmark: Delete Domain stops every sender signature on that domain from sending, and recovery means adding and verifying the domain from scratch. Postmark: Delete Sender Signature makes anything sending from that address fail immediately, and re-adding it means email confirmation again. Postmark: Archive Message Stream stops sending at once and Postmark deletes archived streams 45 days after archiving, restorable with Postmark: Unarchive Message Stream only until the purge date it returns. Postmark: Delete Template breaks any automation still sending with that alias or id, and Postmark documents no restore. Postmark: Delete Inbound Rule is the mildest of the eight, since it only unblocks a sender. If an AI assistant is driving these nodes over MCP, put the destructive ones behind a condition or an approval step rather than leaving them callable.

From AI assistants over MCP

Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and Matter, the assistant built into the platform, can drive the same surface. Postmark also publishes its own MCP server, at github.com/ActiveCampaign/postmark-mcp, maintained under its parent company and linked from Postmark's developer page; it exposes 24 tools covering sending, templates, message search, bounces, suppressions, webhooks, delivery stats and server info, and for an interactive assistant that needs only those, it is a reasonable choice. What this integration adds is coverage, autonomy and custody. Coverage: that server is configured with a server token, a sender address and a stream, so account-level administration, the daily statistics breakdowns, message stream management, bulk broadcast, inbound handling and inbound rules are nodes here rather than tools there. Autonomy: a node is also a canvas step, so the workflow an assistant helps you design then runs on a schedule with nobody present and chains with every other connector in one run. Custody: the credential is held once for a workspace rather than in each person's local config, and the eight destructive nodes are flagged as destructive rather than being one more callable tool. A good split is to hand an assistant the 44 read nodes and gate the writes.

Testing without spending your allowance

Postmark's free developer plan offers 100 emails per month for testing an integration, which Postmark states never expires or runs out, and which includes the REST API, SMTP and Sandbox Mode. Almost everything in this integration costs no email at all: every statistics node, every message and bounce read, the stream, template, webhook and suppression listers, and Postmark: Get Server itself. For the send nodes, set a server's delivery type to Sandbox, either in Postmark or with Postmark: Update Server: a sandbox server accepts mail and discards it, so a send workflow can be exercised end to end without reaching an inbox or spending the allowance. Turn it off afterwards, and be deliberate about which server you set it on, because a production server left on Sandbox accepts every send and delivers none of it. Postmark: Validate Template is the same idea for templates: it renders content against a test model and returns the rendered output plus any syntax errors with line numbers, without saving or sending anything.

Troubleshooting

A node fails with a message saying the account token is missing
This is the integration refusing before it makes a request, not Postmark rejecting you, and it means the node you ran is one of the 25 account-level ones: servers, domains, sender signatures, Postmark: Push Templates Between Servers, or data removal. Postmark authenticates those with X-Postmark-Account-Token, a different header from the server token, and the two are not interchangeable. Open your Postmark Account settings, then its API Tokens page, which is a different page from the one on the server, and copy the account API token into Account API token on the credential. Postmark's API overview describes that token as available to account owners and admins, so if you have no such page, somebody with owner access has to fetch it for you. If you did not intend to administer servers or domains, use a server-level node instead: sending, message search, statistics, bounces, templates, streams, suppressions, webhooks and inbound rules all work without it.
Test Connection fails with a 401
Postmark rejected the server token. The overwhelmingly common cause is the wrong one of Postmark's two tokens: both the server page and the account page are titled API Tokens, and the account token in the server token field produces a 401 that reads exactly like a typo. Confirm you copied the token from the API Tokens tab of the server itself. The other causes are ordinary: the token was regenerated or revoked in Postmark, or the server it belonged to was deleted. Paste it again rather than trusting the field. Note that the account token is never used by the connection test, so a 401 here is always about the server token.
Test Connection fails on the message stream rather than the token
The test deliberately checks two things, because a test that only proved the token would happily bless a transactional stream. After reading the server it reads the stream id you entered in Broadcast message stream and requires Postmark to report its type as Broadcasts. Three failures look different: an empty field fails because the stream is required for campaign sending; a stream that does not exist on this server returns a not-found message, usually because the id came from a different server; and a stream that exists but is transactional or inbound is refused by type. Run Postmark: List Message Streams to see every stream on the server with its type, and use the id of a Broadcasts one. If the server has none, create one with Postmark: Create Message Stream first, and choose the type carefully: it is fixed at creation.
The bulk send node will not accept the message stream I want
That is the guard doing its job rather than a bug. Postmark: Send Bulk Broadcast requires a Broadcast stream with no fallback to the server default, its picker offers Broadcast streams only, it refuses Postmark's reserved transactional stream id by name before making any request, and it reads back whichever stream you chose and rejects it unless Postmark reports its type as Broadcasts. There is no override flag by design. The reason is Postmark's own: bulk mail sent on a transactional stream damages the deliverability of receipts and password resets, and the damage stays invisible until it is expensive. If you genuinely need this send on a transactional stream, it is not a broadcast: use Postmark: Send Email or Postmark: Send Email Batch, which are the transactional paths. If you need a Broadcast stream and do not have one, create it in Postmark or with Postmark: Create Message Stream.
A bulk send reported success but nothing arrived
Bulk sending is asynchronous, so the node returning successfully means Postmark accepted the request, not that anything has been delivered. The response carries a request id, and Postmark: Get Bulk Request is what reports the actual outcome: status, percentage complete, released count and failed count. Check the failed count rather than the status alone, since a request can complete with failures. Postmark: List Bulk Requests shows recent requests if you did not keep the id. If the counts look right and mail still has not arrived, check whether the server's delivery type is set to Sandbox, which makes Postmark accept every message and discard it.
A message search returns nothing for a period I know had traffic
Three causes, in the order worth checking. Retention: Postmark documents message retention as 45 days by default and configurable from 7 to 365 days, and data expires at the end of it, so a search past your retention period returns nothing rather than an error. Time zone: Postmark evaluates fromdate and todate in United States Eastern time, not UTC, so a window built from UTC dates is shifted by hours at both ends and can miss a day entirely at the edges. Filters: on Postmark: Search Inbound Messages the status filter defaults to processed, so blocked, failed, queued and scheduled mail does not appear until you ask for it by status, and on outbound searches the message stream filter narrows to one stream. Also check the count and offset values: this integration does not auto-paginate, count is capped at 500 and count plus offset cannot exceed 10,000, so deep pages are a documented ceiling rather than a fault.
Open or click events are empty even though mail was delivered
Open and link tracking are settings rather than defaults, and no events exist for mail sent without them. Check the server's tracking defaults with Postmark: Get Server, and check whether the send itself overrode them, since the send nodes expose per-message tracking. Postmark: Get Tracked Email Counts is the direct answer: it counts messages sent with tracking enabled, and it is the honest denominator for any open or click rate. Two further points about the numbers. Open tracking depends on a recipient's client loading a remote image, so it undercounts systematically and always has. And unique figures cannot be added across days: one recipient opening on Monday and again on Tuesday is one unique over the pair, so a weekly unique has to be requested for the week rather than summed from dailies.
Removing an address from the suppression list comes back as Failed
Check the reason on the entry first. Postmark documents that spam complaint suppressions cannot be deleted, so those come back with a Failed status by design rather than by fault, while hard bounce and manual suppressions can be removed. The second thing to check is the stream. Suppressions belong to a message stream rather than to the server, so removing an address from your broadcast stream leaves any suppression on another stream untouched, and running the node against the wrong stream finds nothing to remove. Read the list first with Postmark: List Suppressions for that specific stream. Both Postmark: Suppress Addresses and Postmark: Remove Suppressions return one result per address rather than a single verdict, so check every entry's Status instead of reading the HTTP status as the answer.
A webhook was created but receives no events
Postmark verifies a webhook's endpoint against each enabled event type when it is created, every enabled event has to answer 200 for it to be saved as verified, and Postmark documents that an unverified webhook will not receive events until it passes verification. So a webhook created against an endpoint that was not live yet, or that answered anything other than 200 for one of its events, exists and delivers nothing. Run Postmark: Verify Webhook once the endpoint is live: Postmark posts a test payload for each subscribed trigger and reports the status code your endpoint returned for each one, which isolates the failing event rather than the webhook as a whole. Postmark: Get Webhook Statistics then shows delivery health, though only over Postmark's own fixed trailing 24 hours, which cannot be widened.
A picker on a node stays empty
Start with what the picker reads from, since each one is fed by a lister in this integration. If Postmark: List Message Streams returns nothing, no stream picker will populate either. The account-level pickers are the common case: the server, domain and signature pickers are fed by Postmark: List Servers, Postmark: List Domains and Postmark: List Sender Signatures, which all need the account token, so without one you see the missing-token explanation in the config panel rather than an empty list. Two fields carry no picker on purpose and are not broken: the ID on Postmark: Create Message Stream is an id you invent for a stream that does not exist yet, and the data removal id has no lister because Postmark exposes create and status for data removals but no list endpoint.
Requests start failing with a 429
Postmark documents a 429 Rate Limit Exceeded response for making requests at a rate that exceeds acceptable use of the API, and does not publish a specific per-minute number, so the fix is shape rather than a target rate. This integration does not auto-paginate, so each node is exactly one request and an unbounded walk cannot hide behind a single canvas step; if you built a loop that pages through results, slow it down or widen each page instead, remembering that count is capped at 500 and count plus offset cannot exceed 10,000. Prefer the nodes where Postmark has already done the arithmetic: Postmark: Get Sending Overview and Postmark: Get Delivery Stats each replace a walk over individual messages. Two other status codes are worth recognising while you are here: a 413 means the payload was too large, which Postmark's overview documents as a 10 MB limit while its batch and bulk endpoints document a 50 MB payload allowance, and a 422 means the request reached Postmark and was rejected as malformed or invalid rather than throttled.
Mail is accepted by Postmark but never arrives anywhere
Check the server's delivery type first, with Postmark: Get Server. A server set to Sandbox accepts every message and discards it, which is exactly what you want while testing and completely silent if it was left on by mistake. Postmark: Update Server changes it back. If the server is not in sandbox, the next things to check are the sender signature and the domain: a From address whose signature is unconfirmed cannot send, which Postmark: List Sender Signatures shows, and domain verification state is in Postmark: List Domains. Both of those reads need the account token. After that, Postmark: Search Outbound Messages followed by Postmark: Get Outbound Message gives the full event timeline for one message, including transient failures and bounces, which usually names the real cause.

Postmark is a trademark of its respective owner. Mattering uses platform names to identify the services these integrations connect to; no endorsement or affiliation is implied.

Start Free Explore our Products