canonical: https://jentic.com/apis/postmarkapp.com

# Postmark APIs

Postmark is a transactional email platform. Its APIs cover two layers: server-level email operations (sending single, batch, and templated messages, tracking opens and clicks, managing bounces, and processing inbound mail) and account-level infrastructure (provisioning servers, verifying sending domains with DKIM and SPF, managing sender signatures, and distributing templates across environments).

## For AI agents

An agent can send transactional and templated emails, track delivery, opens, clicks, and bounces on a Postmark server, and separately provision servers, verify sending domains via DKIM and SPF, manage sender signatures, and push templates across the account.

## Scope

Use for: Transactional email sending with delivery, open, click, and bounce tracking on a Postmark server, plus account-level provisioning of servers, domain DKIM and SPF verification, and sender signature management.

Not supported:
- marketing campaigns
- contact list management
- SMS messaging
- on-prem deployment
- custom IP pools

## APIs

| API | Category | Endpoints | Description |
| --- | --- | --- | --- |
| Postmark Server API | communications | 43 | Send transactional emails, manage bounces, track delivery statistics, render templates, and process inbound messages for a specific Postmark server. |
| Postmark Account-level API | communications | 23 | Manage Postmark account infrastructure including servers, domains with DNS verification, sender signatures, and cross-server template distribution. |

## Which API to use

| Need | API | Why |
| --- | --- | --- |
| Send transactional or templated email and track delivery | server | The Server API sends single, batch, and template-based messages and returns open, click, and bounce statistics for one server. |
| Manage bounces and inbound message processing | server | Bounce listing, reactivation, and inbound trigger rules live on the Server API, scoped to a single sending server. |
| Provision servers or verify sending domains | account | The Account-level API creates servers and verifies domain DKIM, SPF, and Return-Path records, which the Server API cannot do. |
| Manage sender signatures and cross-server template distribution | account | Sender signature creation, verification, and pushing templates between servers are account-level operations. |

## Cross-API use cases

### Stand up a new sending environment end to end

Provision a fresh Postmark server, verify its sending domain, then start sending templated transactional mail through it. The account-level API creates the server and confirms domain DKIM and SPF, and the server-level API sends and tracks the first messages.

Example prompt: Create a server via POST /servers and verify its domain DKIM and SPF on the account API, then switch to the server token and send a templated message via POST /email/withTemplate, confirming delivery through GET /messages/outbound/{messageid}/details

### Deploy templates across environments and validate delivery

Push email templates from a staging server to production, then send a test transactional email on the destination server and confirm it renders and delivers. Template distribution is account-level and the test send plus tracking is server-level.

Example prompt: Call POST /templates/push on the account API to copy templates to the production server, then send a templated message with POST /email/withTemplate and read GET /stats/outbound to confirm the send

### Audit domain authentication before a sending run

Check that a sending domain's DKIM and SPF records are verified at the account level, then review recent bounce and delivery statistics on the server before scaling up sends. This pairs account-level authentication checks with server-level deliverability signals.

Example prompt: Verify domain records with PUT /domains/{domainid}/verifydkim and PUT /domains/{domainid}/verifyspf on the account API, then pull GET /bounces and GET /stats/outbound on the server API to confirm the domain is healthy before a larger send

## Why Jentic

- **Setup:** Wiring Postmark by hand means handling two different token headers, X-Postmark-Server-Token for sending and X-Postmark-Account-Token for infrastructure, and targeting api.postmarkapp.com for every call. With Jentic you install once, add the Postmark APIs you need from the Jentic directory, store each token once, and your agent calls the operations.
- **Permission scoping:** Scoping differs by layer: server operations take the email target in the request body, so you scope by operation such as sending or reading bounce stats, while account operations put the domain id in the path, letting a rule pin the agent to one domain. Your own Jentic One rules decide which operations across both APIs the agent may call, so writes like rotating DKIM or provisioning servers are excluded unless you add them.
- **Credential handling:** Both the Postmark server token and the account token are stored once, encrypted, by your own Jentic One instance and injected at execution time. Neither enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search the Jentic directory by intent such as 'send a transactional email' or 'verify a sending domain's DNS', and Jentic returns the matching Postmark operation with its input schema, so the agent reaches the right endpoint on the right API without browsing the reference docs.

## Related vendors

- **SendGrid** — Email delivery platform with high-volume sending, dedicated IPs, and marketing plus transactional support.
- **Mailgun** — Transactional and bulk email API with domain authentication and inbound routing, a direct Postmark alternative.
- **SparkPost** — Email delivery service with sending domain and IP pool management for larger-scale programs.
- **Mandrill** — Transactional email from Mailchimp with merge-tag templating and conditional content.

## FAQ

### What is the difference between the Server API and the Account-level API?

The Server API handles individual email operations for one sending server: sending messages, tracking opens and clicks, managing bounces, and processing inbound mail. The Account-level API manages infrastructure across the whole account, including provisioning servers, verifying sending domains, and managing sender signatures. They use different tokens.

### Does one credential work across both Postmark APIs?

No. The Server API authenticates with a per-server token in the X-Postmark-Server-Token header, and each server in your account has its own. The Account-level API uses a separate account token in the X-Postmark-Account-Token header. An agent working across both layers needs both tokens.

### Can an agent set up a new sending environment from scratch?

Yes. The Account-level API creates a server and verifies its sending domain through DKIM and SPF checks, and the Server API then sends and tracks the first transactional emails on that server. The two APIs together cover provisioning, authentication, and sending.

### Are these APIs suitable for marketing email?

Postmark is built for transactional email such as password resets, receipts, and notifications, with fast delivery and per-server statistics. It does not provide contact list management, campaign scheduling, or bulk marketing features, so use a dedicated marketing platform for those needs.

### How do templates move between servers?

Template distribution is an account-level operation. POST /templates/push on the Account-level API copies templates from a source server to a destination server, which lets you promote consistent templates from staging to production. The Server API then renders those templates when sending.

### How does an agent pick the right API for a task?

If the task is sending, tracking, or bounce handling for one server, use the Server API. If it is provisioning servers, verifying domains, managing sender identities, or distributing templates, use the Account-level API. An agent searching Jentic by intent is routed to the matching operation on the correct API.