A Courier MCP that models preferences properly and never hides a send
80 nodes on Courier's notification API: 41 that read and 39 that act. Sending, bulk jobs, broadcasts, journeys and automations; the delivery log with per-provider status; user profiles, list membership, device tokens and tenants; and the subscription and preference model in full, because that is the reason to run Courier rather than one email provider. Nine of the 80 can put a message in front of a real person, and every one of them says so in the first line of its own description.
What the Courier MCP connector does
The Courier connector for Mattering Automations is 80 nodes on the Courier API at api.courier.com, authorized by one API key. Courier is notification infrastructure: you describe one logical message and Courier decides which channels each recipient actually receives it on, using the routing rules, the recipient's stored profile and their preferences. The nodes follow that shape. Sending covers a single send, the four-step bulk flow, the broadcast fire verbs and the journey and automation invokes. The delivery log covers listing messages, reading one, reading its status history and reading the content that was actually rendered. The recipient directory covers user profiles, list membership, push device tokens and tenant membership. The catalogs cover lists, templates, brands, tenants, routing strategies, audiences, providers, journeys, automations, broadcasts and the preference sections that feed every topic picker in the connector. Forty one nodes read and thirty nine act.
Every capability is a step on the Automations canvas, and every node speaks MCP, the open protocol for connecting AI assistants to tools. Claude, ChatGPT, and any MCP-capable assistant can use them, alongside Matter, the AI assistant built into the platform. So the same node that an agent calls in a conversation is the node a scheduled workflow runs at three in the morning with nobody present, and it chains with every other connector in the same canvas.
This connector sends for real, and the page is not going to bury that under a feature list. Seven nodes open their description with the words SENDS FOR REAL: send message, send broadcast, schedule broadcast, run bulk job, invoke journey, invoke automation and resend message. Two more open with MAY CAUSE A REAL SEND, because they do not deliver anything themselves but what they start can: track event, which is the trigger a journey listens for, and release digest, which flushes whatever has accumulated for every waiting user at once. A test run of any of the nine reaches a real inbox, phone or device on infrastructure the recipient never agreed to be tested against, and it spends the workspace's send quota. Nothing in a node can prevent that, because the only real control lives on the credential, which is why the setup section below spends its time on Courier's Test and Production environments rather than on where to click.
Preferences get twelve nodes and template content gets none, and that asymmetry is the argument the connector is making. Courier's value is routing one notification across channels according to what each person agreed to receive, and the objects that encode that are subscription topics and user preferences. A workflow touches them constantly: at signup, at unsubscribe, when somebody flips a toggle in a preference centre, and immediately before a send that has to respect a choice. So all six user preference operations ship, along with the topic catalog, topic reads and writes, and the node that publishes the hosted preference page. Three details the nodes carry that Courier's own docs bury: a preference read returns the person's own status alongside default_status, so a workflow can tell a deliberate opt-in from a person who has never chosen; REQUIRED is a topic-level default set in the preferences editor rather than a user choice, which is how transactional messages stay deliverable; and the PUT and POST forms of a bulk preference write differ only in what they do to topics you did not mention, where the PUT resets them and an empty list wipes every override the person has. Both ship, labelled by exactly that difference.
Seventy nine of Courier's 155 documented operations ship as named nodes, and an eightieth reaches everything else, so it is worth saying plainly what the other 76 operations are rather than leaving a gap. The authoring surfaces are out: template content and its Elemental elements, locale overrides, template submission checks, journey graphs and journey-scoped templates, broadcast creation and content, brand styling documents and routing strategy rule documents. Those are designed in Courier's editor by a person looking at a preview, and a palette node that rewrites them sitting one click below the node that reads them is how accidents happen. Tenant templates and translations are out for the same reason. Provider configuration is out for a different one: creating or updating a provider means posting the workspace's SendGrid, Twilio or Firebase credentials through node config, which is the exact thing a secrets model exists to prevent, and the provider lister that does ship blanks every settings object on the way out. One cut is worth naming on its own. Courier exposes both POST and PUT on the same list subscriptions URL, and the PUT overwrites the entire subscriber set, silently unsubscribing everyone who was not named in the body. The additive POST ships and the PUT does not.
Nothing cut is unreachable. Courier: API Request is an advanced node that calls any Courier API endpoint directly with the connection's credential applied, so template publishing, list restore, translations and the deletes that were deliberately kept off the palette are all one deliberate configuration away. It is flagged destructive and its description says to treat it as a sending node, because nothing stops a caller pointing its path at the send endpoint. Prefer a named node whenever one exists: the named nodes carry the warnings, the sample outputs and the pickers that a raw request cannot.
Courier ships its own MCP server, hosted at mcp.courier.com, and Courier's tutorials point at it for exactly this use case. It is good, it covers more of the API surface than this connector does, and if all you want is a send tool inside Cursor or a local assistant config, use it. What this connector adds is the rest of the platform around the same API. The nodes run on a schedule or off another system's trigger with nobody present. They chain with every other connector in one workflow, so a form submission, a CRM update and a Courier send are three steps on one canvas rather than three integrations. The API key is held once in a shared workspace credential store rather than pasted into each person's own MCP config file. And the sending nodes carry destructive flags and written warnings that a generic tool list does not, which matters more here than on most connectors, because the mistake is externally visible and cannot be undone.
On plans, the honest position is that this is cheap to try. Courier's Developer plan is free, includes 10,000 sends per month, and includes API access with the SDKs and CLI; the free tier meters sends rather than switching features off. One plan gate does exist and the connector is explicit about it. Courier: Get Template Metrics answers HTTP 402 with a payment required error when the requested range exceeds the plan's maximum lookback, which Courier documents as 30 days on Developer and 90 days on Business. That is a billing answer arriving where a workflow expects a validation answer, so a 90 day funnel backfill on a free workspace fails in a way that reads like a broken connector rather than a plan boundary.
One connection, three surfaces
- Visual automations. Drag Courier nodes onto the canvas and wire them to triggers, conditions, and other apps.
- AI agents, yours or ours. These nodes speak MCP, the open protocol, so Claude, ChatGPT, and any MCP-capable assistant can use them, and Matter, the agent built into the platform, uses them natively.
- The whole platform. Combine with native tasks, projects, and other connectors, no middleware in between.
Every Courier node, ready to drop on the canvas
80 nodes, generated from the connector itself so this list always matches what ships. Expand a category to browse.
Read and query nodes 41
Courier: Get Audience
Read one audience with its name, description and the filter that decides membership. Read it before changing it: Courier: Create or Replace Audience replaces the filter wholesale, so this node is how a workflow gets the current definition to modify rather than to overwrite blindly.
Courier: Get Audit Event
Read one audit event by id, with the actor who performed it, the target they changed, the source, the event type and a timestamp. Reach for it after Courier: List Audit Events when a single change needs to be attached to a ticket or a review.
Courier: Get Broadcast
Read one broadcast by id: its name, channel, status, schedule and audit fields. Check status here before sending or scheduling, because Courier refuses both once a broadcast is already sending or sent and answers 409. An archived broadcast returns 404 rather than a record with an archived flag.
Courier: Get Bulk Job
Read a bulk job's message definition, its status and its running counts. Status moves CREATED to PROCESSING to COMPLETED, or to ERROR. The three counters are the useful part: received is how many users were ingested, enqueued is how many messages Courier accepted, and failures is the difference worth alerting on. Poll this after Courier: Run Bulk Job to follow a batch to completion.
Courier: Get Journey Run
Read one journey run by the runId an invoke returned: its status, its journey, when it was created and last updated, and what started it. The natural follow-up to Courier: Invoke Journey when a workflow needs to know whether the sequence finished. Courier returns the SAME 404 for an unknown run, a run in another workspace, a run past the 95-day retention window and an Automation run id, so a 404 here proves nothing about where the run might exist.
Courier: Get List
Read one list by id with its name and created and updated timestamps. Subscribers are a separate resource: use Courier: List List Subscriptions for those. A useful existence check before a broadcast, since several subscription endpoints create a missing list silently rather than failing.
Courier: Get Message
Read one sent message: its status, recipient, event and per-provider delivery detail, with epoch-millisecond timestamps for enqueued, sent, delivered, opened and clicked. A zero in one of those means it has not happened rather than that it happened at the epoch. The providers array is the part worth reading on a failure: it says which integration was tried and what it answered, which is usually the difference between a Courier problem and a provider problem.
Courier: Get Message Content
Read the rendered content Courier actually delivered for a message, broken out per channel. This answers what did the recipient really see, after template variables were interpolated and the brand applied, which is not something the template alone can tell you. Useful for support tickets and for auditing a send whose data came from an upstream node. The body may contain personal data, so treat the output as it would be treated in an inbox.
Courier: Get Message History
Read the ordered event history of one message, one entry per status transition with its timestamp. Where Courier: Get Message gives the current state, this gives the path it took, which is what you need when a message was FILTERED or THROTTLED and someone wants to know at which step Courier decided that.
Courier: Get Notification Template
Read one notification template: its name, alias, tags, brand, subscription topic, routing and its Elemental content. Returns the PUBLISHED version by default, which is what a send would actually render, so a draft edited in Courier's editor will not appear here until it is published. Useful for an agent that has to explain or summarise what a template says before sending it. Editing template content is not part of this connector; that work belongs in Courier's editor.
Courier: Get Preference Topic
Read one subscription topic: its default status, its routing options, which controls a recipient may customise, and whether emails about it carry a list-unsubscribe header. Read this before writing a user preference, because default_status REQUIRED means Courier will refuse to opt anyone out and the write would fail for a reason nothing else explains.
Courier: Get Profile
Read a user's stored profile and preferences: the email address, phone number, push tokens and custom fields Courier can reach them on. A send addressed by user_id resolves its destinations from exactly this record, so when a message comes back UNROUTABLE this is the first place to look. The response carries contact details for a real person, so treat it as personal data.
Courier: Get Template Metrics
Read the delivery funnel for one notification template as a time series: sent, delivered, opened, clicked, errors and undeliverable, broken out per provider and channel INSIDE each bucket. There is no bucket-level total, so sum the entries in a bucket to get one. This is the only reporting endpoint in the connector and the one to chart when someone asks whether a notification is working. Every bucket in the window comes back including empty ones, so the series plots without gap filling. Four behaviours to know: the window is snapped OUTWARDS onto the granularity grid and the snapped bounds come back in the response, so align a chart on those rather than on what was requested; every boundary is UTC with no timezone support; an unknown template id returns an all-empty series rather than a 404; and messages sent without a template never appear here. Available in the US region only.
Courier: Get Tenant
Read one tenant: its name, parent, brand, properties, default preferences and the user_profile merged into every member on send. Always run this before Courier: Create or Replace Tenant, because that node replaces rather than merges and this is how you get the current values to send back. The default_preferences block is the part with reach: it decides what every member receives unless they have set their own override.
Courier: Get User Device Token
Read one device token with its provider key, status and status reason, expiry date, device details and any properties stored alongside it. The status_reason is the field worth reading: it is where Courier records that a provider reported the token unregistered, which is the signal to stop targeting that device rather than to retry.
Courier: Get User List Subscriptions
List the lists a user is subscribed to, each with the preferences recorded for that subscription. Answers what will this person receive from a list-targeted send, which is the check worth running before a broadcast rather than after it. Paged by cursor: the response carries paging.more and paging.cursor, and rows are under results. Pass the cursor back in the cursor field for the next page.
Courier: Get User Preferences
Read a user's preference overrides, one row per subscription topic they have expressed a choice about. Each row carries both status, which is what the person chose, and default_status, which is what they would get if they had not. Reading both is the point: opted in by choice and opted in by default look identical if you only read one, and they are completely different facts at unsubscribe time. Preferences resolve user override first, then tenant default, then the topic's workspace default. Paged by cursor: the response carries paging.more and paging.cursor, and rows are under items. Pass the cursor back in the cursor field for the next page.
Courier: Get User Topic Preference
Read one user's opt-in status and channel choices for one subscription topic, or the effective default if they have never set an override. This is the check to run immediately before a send that must respect a choice, and it is cheaper than reading every preference the person has. has_custom_routing tells you whether custom_routing is actually in force or is just left over.
Courier: List Audience Members
List the users currently matching an audience filter. This is the dry run for an audience-targeted broadcast: the only way to see who a send would reach before sending it. Membership is recalculated rather than stored, so the answer moves as profiles change and a count taken an hour ago is a guess. Each row carries the audience_version it matched under and a reason. Paged by cursor: the response carries paging.more and paging.cursor, and rows are under items. Pass the cursor back in the cursor field for the next page.
Courier: List Audiences
List the workspace's audiences. An audience is a filter over user profiles rather than a stored membership list, so it recalculates as profiles change and a send to it reaches whoever matches at that moment. That is the difference from a list, and it is the reason an audience-targeted broadcast can be a different size than the last time anyone checked. Picker source for audience id fields. Paged by cursor: the response carries paging.more and paging.cursor, and rows are under items. Pass the cursor back in the cursor field for the next page.
Courier: List Audit Events
List the workspace's audit log. Each event records the actor who made a change, the target they changed, the source, the event type and an ISO 8601 timestamp, which is what answers who edited this template or who changed this tenant's defaults. Note what this endpoint does NOT accept: there is no date range, no type filter and no actor filter, only a cursor. A workflow that wants recent events pages from the newest and filters on timestamp itself. Paged by cursor: the response carries paging.more and paging.cursor, and rows are under results. Pass the cursor back in the cursor field for the next page.
Courier: List Automation Runs
List runs of the workspace's v2 Automations, newest first, filtered by status, template or creation date. The v2 twin of Courier: List Journey Runs, and the two surfaces are strictly separate: neither ever returns the other's runs, so a monitoring workflow on a mixed workspace has to poll both. Runs are retained for 95 days. Paged by cursor, but NOT in this API's usual shape: rows are under runs and the cursor is a flat next_cursor with no paging object and no more flag. A loop written against paging.more never terminates here. Stop when next_cursor comes back empty.
Courier: List Automations
List the workspace's saved v2 Automation templates. Automations are the generation before Journeys; workspaces that predate the journey editor still run them, and their ids are what Courier: Invoke Automation takes. If this returns nothing, the workspace is journey-only and Courier: List Journeys is the node you want. Paged by cursor, returned as a flat cursor field with rows under templates.
Courier: List Brands
List the workspace's brands with their colours, logo, email layout overrides, in-app styling and Handlebars snippets. A brand is what makes one template render in a customer's own colours, which is the other half of multi-tenancy alongside tenants. Picker source for every brand id field here. Brand authoring is not part of this connector; brands are designed in Courier. Paged by cursor: the response carries paging.more and paging.cursor, and rows are under results. Pass the cursor back in the cursor field for the next page.
Courier: List Broadcasts
List the workspace's broadcasts, newest first. A broadcast is a one-off single-channel message to a list or an audience, authored in Courier and fired by id. Each entry carries its channel, its lifecycle status (draft, scheduled, sending, sent) and its schedule, so this is the node that answers whether something has already gone out before another node sends it again. This is also the picker source for every broadcast id field in the connector. Archived broadcasts are excluded. Paged by cursor: the response carries paging.more and paging.cursor, and rows are under results. Pass the cursor back in the cursor field for the next page.
Courier: List Bulk Job Users
List the users ingested into a bulk job, each with the status Courier recorded and the id of the message it produced. Two uses: check the batch BEFORE running it, which is the only review step the bulk flow has, and afterwards follow a messageId into Courier: Get Message to see why one recipient failed while the rest succeeded. Paged by cursor: the response carries paging.more and paging.cursor, and rows are under items. Pass the cursor back in the cursor field for the next page.
Courier: List Journey Run Steps
List the per-node state of one journey run, in full. This is the debugging node: it shows which branch a run took, where it is waiting and which step failed. NOT paginated, so one call returns everything. Each step's node_id matches the node in the published journey graph, so the trace maps straight onto the editor. Send steps that produced a message carry a message_id; follow it to Courier: Get Message for delivery status, which is how you tell the journey ran correctly but the email bounced from the journey never getting there.
Courier: List Journey Runs
List journey runs, newest first, filtered by status, journey or creation date. This is the operational view of what Courier is currently doing: how many runs of the onboarding sequence are in flight, which ones errored, whether last night's batch actually started. Runs are retained for 95 DAYS and vanish after that, so anything needed for longer has to be copied out. Runs of the older v2 Automations do NOT appear here; use Courier: List Automation Runs for those. Paged by cursor, but NOT in this API's usual shape: rows are under runs and the cursor is a flat next_cursor with no paging object and no more flag. A loop written against paging.more never terminates here. Stop when next_cursor comes back empty.
Courier: List Journeys
List the workspace's journeys, each with a name, id (jry_ prefix) and version. A journey is a multi-step notification sequence built in Courier's editor: wait, branch, send, repeat. This node is how a workflow finds the journey it means to invoke, and it is the picker source for every journey id field here. Journeys are Courier's v3 automation surface; the older v2 templates are listed by Courier: List Automations instead and the two never overlap. Paged by cursor, returned as a flat cursor field with rows under templates.
Courier: List List Subscriptions
List the users subscribed to a list, each with the preferences recorded for that subscription. Run this before Courier: Send Broadcast to know how many people a campaign will actually reach, which is the one number the send endpoint will not tell you in advance. Paged by cursor: the response carries paging.more and paging.cursor, and rows are under items. Pass the cursor back in the cursor field for the next page.
Courier: List Lists
List the workspace's lists. A list is a named set of subscribers that a send or a broadcast can target as one recipient. Ids are dot-delimited strings you choose, which is what makes the pattern filter useful: a hierarchy like example.region.emea can be queried a branch at a time. This is the picker source for every list id field in the connector. Paged by cursor: the response carries paging.more and paging.cursor, and rows are under items. Pass the cursor back in the cursor field for the next page.
Courier: List Messages
List previously sent messages, most recent first, each with its status, recipient, channel and provider. This is the delivery log: filter by recipient to answer did this person get it, by notification to see how one template is performing, by status to find failures, or by tag if the send set metadata tags. Statuses that mean trouble are UNROUTABLE (no channel could be resolved), UNDELIVERABLE (the provider rejected the address) and UNMAPPED (the template was not found); each also carries a reason such as BOUNCED or UNSUBSCRIBED. Timestamps here are epoch MILLISECONDS. Paged by cursor: the response carries paging.more and paging.cursor, and rows are under results. Pass the cursor back in the cursor field for the next page.
Courier: List Notification Templates
List the workspace's notification templates, each with its title, id (nt_ prefix), routing, tags, subscription topic and draft or published state. This is how a workflow finds the template it means to send, and it is the picker source for every template field in the connector. The topic_id on each row is worth noting: it is what ties a template to the preference a recipient controls, so a template with no topic ignores preferences entirely. Paged by cursor: the response carries paging.more and paging.cursor, and rows are under results. Pass the cursor back in the cursor field for the next page.
Courier: List Preference Sections
List the workspace's preference sections, each with its subscription topics embedded. A section is a heading on the hosted preference page and a topic is one thing a recipient can opt in or out of, so this single call returns the entire catalog of what this workspace can notify people about. It is the picker source for every topic id field in the connector, which is why it matters that the topics come back nested rather than needing a call per section. Not paginated.
Courier: List Preference Topics
List the subscription topics inside one preference section, each with its default status, routing options and the controls a recipient is allowed to customise. Narrower than Courier: List Preference Sections and the right node when a workflow already knows which section it cares about. Not paginated.
Courier: List Providers
List the provider integrations configured in the workspace, one entry per channel and provider key with its alias and title. This answers what channels can this workspace actually send on, which is the first thing to check when a message comes back UNROUTABLE: no configured provider for a channel means Courier has nowhere to route it. Each provider's settings object is BLANKED by this node, because that is where the workspace's SendGrid, Twilio and Firebase credentials live and they have no business appearing in an automation's output. Paged by cursor: the response carries paging.more and paging.cursor, and rows are under results. Pass the cursor back in the cursor field for the next page.
Courier: List Routing Strategies
List the workspace's routing strategies with their names, descriptions and tags. A routing strategy is a reusable channel and provider failover rule that templates share, for example email through SendGrid with SES as backup. This node returns METADATA ONLY: the routing rules, channels and providers themselves are not included. Use it to see what strategies exist and to populate a picker; editing them belongs in Courier. Paged by cursor: the response carries paging.more and paging.cursor, and rows are under results. Pass the cursor back in the cursor field for the next page.
Courier: List Tenant Users
List the users belonging to a tenant, each with the tenant-scoped profile that overrides their workspace profile for sends in this context. This is how you size the blast radius of a tenant-scoped write before making it, and how you answer who would a tenant-targeted send reach. Paged by cursor in the tenant shape: rows are under items, and the cursor and has_more flag sit at the TOP LEVEL rather than inside a paging object.
Courier: List Tenants
List the workspace's tenants, each with its name, parent, brand, properties and default preferences. A tenant is an organization, team or account your users belong to, and it is how one Courier workspace serves many customers without one template per customer. Tenants nest, so filtering by parent walks a hierarchy a level at a time. Picker source for every tenant id field here. Paged by cursor in the tenant shape: rows are under items, and the cursor and has_more flag sit at the TOP LEVEL rather than inside a paging object.
Courier: List User Device Tokens
List every push device token registered for a user, each with its provider key, status and expiry. This answers can we actually reach this person on push, which is the usual explanation for a push send that came back UNROUTABLE. Tokens default to a two month expiry, so a user who has not opened the app in a while may have none left. Not paginated.
Courier: List User Tenants
List the tenants a user belongs to, with the per-tenant profile held for each. One person can belong to many tenants and carry different contact details and preferences in each, which is why a send that leaves out tenant context can reach them with the wrong branding. Paged by cursor in the tenant shape: rows are under items, and the cursor and has_more flag sit at the TOP LEVEL rather than inside a paging object.
Action nodes 39
Courier: API Request
Call any Courier API endpoint directly, with the connection's credential applied. This connector ships 79 curated nodes out of Courier's 155 documented operations, and this is how the rest stay reachable: template and journey authoring, Elemental content and locale overrides, tenant templates, translations, provider and brand and routing-strategy management, broadcast creation and duplication, list restore, journey publishing and the destructive deletes deliberately kept off the palette. TREAT IT AS A SENDING NODE. Nothing stops a path of /send or a broadcast send from here, so it can deliver real notifications and spend real quota. Read Courier's API reference for the path, method and body you need, and prefer a named node whenever one exists, because named nodes carry the warnings and the pickers that this one cannot.
Courier: Add Bulk Job Users
Add recipients to an open bulk job. Still no delivery: users accumulate on the job until Courier: Run Bulk Job starts it. Call this as many times as the batch needs, feeding it pages from a database, a list or an upstream node. For an email batch put the address in profile.email rather than in to.email: Courier resolves provider routing from the profile, so an address in the wrong place produces an UNROUTABLE message rather than an error you can see here.
Courier: Add List Subscribers
Add subscribers to a list WITHOUT touching the ones already on it. This is the additive write and the one a workflow almost always wants. Courier also exposes a PUT variant that OVERWRITES the entire subscriber set, which is not in this catalog precisely because the two are one HTTP verb apart and the wrong one silently unsubscribes everybody; reach it through Courier: API Request if a full replace is genuinely intended. A list that does not exist is created. Rate limited to 20 requests per minute.
Courier: Add User Device Token
Register one push device token for a user against a provider, overwriting it if the same token value already exists. This is the node an app calls at login and on token refresh, and keeping it current is what makes push sends resolve. Tokens expire after two months by default; set expiry_date to change that, or to false to disable expiry entirely, which is worth avoiding because a dead token then never ages out.
Courier: Add User to Tenant
Add one user to one tenant, optionally with a tenant-specific profile that overrides their workspace profile for sends in that context. This is the node an invite-accepted or seat-assigned workflow calls. Adding somebody subscribes them to that tenant's default preferences, so they start receiving whatever the tenant has defaulted to opted in. Scoped to one tenant: their other memberships and their workspace profile are untouched.
Courier: Cancel Broadcast Schedule
Cancel a broadcast's pending schedule and return it to draft. This is the undo for Courier: Schedule Broadcast and the only way to stop a scheduled campaign from the API. It is valid only while the broadcast is still scheduled: once it has started sending, Courier answers 409 and there is nothing to cancel.
Courier: Cancel Journey Runs
Stop journey runs that are still in flight, so a sequence abandons the messages it has not sent yet. This is the node that turns a multi-day nudge sequence off when the thing it was nudging about actually happens. Supply EXACTLY ONE of a cancelation token, which cancels every run sharing it, or a run id, which cancels one. Supplying both or neither is a 400. Cancelling stops future steps; it does not recall anything already delivered.
Courier: Cancel Message
Cancel a message that is still in the delivery pipeline and return the record with its resulting status. This only works while the message is genuinely pending, which in practice means a delayed, digested or scheduled send: once a provider has accepted it there is nothing to cancel and the status comes back unchanged. Pair it with a send that carried a delay when you need a window in which a workflow can change its mind.
Courier: Create Bulk Job
Open a bulk job: the message definition that a large batch of recipients will be sent. Nothing is delivered by this node. The bulk flow is four calls in order: create the job here, add users to it with Courier: Add Bulk Job Users (repeat as often as needed), start it with Courier: Run Bulk Job, then poll Courier: Get Bulk Job for counts. Only the run step sends. Reach for bulk rather than a loop of single sends when the recipient set is large: Courier enqueues the whole batch server-side, so the workflow does not have to survive the run.
Courier: Create Client Token
Issue a short-lived JWT for a client-side Courier SDK, such as the in-app inbox or the hosted preference centre. This is the supported way to let a browser or mobile app talk to Courier without ever holding the workspace API key. THE RESPONSE IS A LIVE CREDENTIAL and is deliberately not redacted, because returning it is the whole purpose of the node: treat the output as a secret, hand it straight to the client that needs it, and do not log it. The scope string is what confines the token: include user_id:<their id> or the token is not tied to one person at all. Keep expires_in short.
Courier: Create Preference Topic
Create a subscription topic inside a preference section, so a new category of notification becomes something recipients can control. The default_status is the consequential field: OPTED_IN means everyone receives it until they say otherwise, OPTED_OUT means nobody does until they ask, and REQUIRED means the choice is not offered at all, which is correct for transactional messages and wrong for anything marketing. The new topic is not visible to recipients until Courier: Publish Preferences Page runs.
Courier: Create or Merge Profile
Merge values into a user's profile, creating it if it does not exist and leaving every key you omit untouched. This is the everyday write and the one almost every workflow wants: sync a changed email address without knowing or resending the rest of the record. Use Courier: Replace Profile only when the intent is genuinely to discard whatever else is stored.
Courier: Create or Replace Audience
Create an audience with this id or replace it. Membership recalculates automatically from the filter, so a change here changes who receives the NEXT audience-targeted send with no further action, and widening a filter by mistake widens the next broadcast with it. Read the audience first and modify what comes back rather than composing a filter from scratch.
Courier: Create or Replace List
Create a list with this id, or replace its name and default preferences if it already exists. Subscribers are untouched: they are managed through the subscription nodes, so this is safe to run against a populated list. Because it replaces rather than merges, omitting preferences clears the list's defaults.
Courier: Create or Replace Tenant
Create a tenant with this id, or REPLACE it if it exists. The replace is the thing to be careful about, because a tenant is shared by everyone in it: omitting default_preferences does not leave the existing defaults alone, it clears them, and the next send to that tenant routes by workspace defaults instead. On a tenant with thousands of members that is thousands of people whose notification settings changed because one field was left out of one call. Read the tenant with Courier: Get Tenant, merge your change into what comes back, then write. Deleting a tenant is deliberately not a node here; use Courier: API Request if it is genuinely needed.
Courier: Delete List
Delete a list, which immediately halts any send that targets it. Recoverable, unusually for a delete: Courier keeps the list and its subscribers and can restore both, though the restore endpoint is not in this catalog and is reached through Courier: API Request. Broadcasts and scheduled sends pointed at this list will fail rather than silently deliver to nobody.
Courier: Delete Profile
Delete a user's profile and the contact details stored with it. Courier documents no undelete, so this is permanent and any later send addressed by that user_id has nothing to resolve. It is NOT a complete erasure: list subscriptions and preference overrides are separate resources and survive, so a right-to-be-forgotten flow also needs the list-subscription and preference deletes, which are separate nodes.
Courier: Delete User Device Token
Delete one device token so push sends stop targeting that device. Call it at logout and when a provider reports a token as unregistered. Reversible in the sense that the app can register the token again; the record itself is gone.
Courier: Delete User Topic Preference
Remove a user's override for one topic, resetting it to the effective default from the tenant or the workspace. Careful with this one: if the topic's default is OPTED_IN, deleting the override of somebody who opted OUT re-subscribes them. It is the right node for undoing a mistaken write, and the wrong node for tidying up. Courier answers 204 whether or not an override existed.
Courier: Invoke Automation
SENDS FOR REAL. This node delivers to live destinations and spends the workspace's notification quota, so a test run reaches a real inbox, phone or device. Use a Courier TEST environment key while building: Courier scopes keys per environment and a test key never sends real notifications. Start a run of a saved v2 Automation for one recipient and get back a runId. Same shape and same caution as Courier: Invoke Journey: the run executes asynchronously and everything the automation would send gets sent. Use this only for workspaces still on v2 templates; new work belongs in a journey. Set an idempotency key so a retry does not start a second run.
Courier: Invoke Journey
SENDS FOR REAL. This node delivers to live destinations and spends the workspace's notification quota, so a test run reaches a real inbox, phone or device. Use a Courier TEST environment key while building: Courier scopes keys per environment and a test key never sends real notifications. Start a journey run for one user. Everything the journey would send gets sent, possibly over days, so one call here can produce many notifications and the workflow that made it is long gone by the time the last one goes out. Courier answers 202 with a runId before anything is delivered. Give it a user_id, or a profile carrying enough contact detail to resolve one. Set an idempotency key: a retried invoke without one starts a second run of the same sequence for the same person. Stop a run with Courier: Cancel Journey Runs.
Courier: Publish Preferences Page
Publish the workspace's hosted preference page, snapshotting every section and topic as they stand and returning the page id and a preview URL. Topic changes are invisible to recipients until this runs, which makes it the deploy step for the preference catalog: create or edit topics, then publish. It publishes whatever is currently configured, so an in-progress edit gets published too.
Courier: Release Digest
MAY CAUSE A REAL SEND. This node does not deliver anything by itself, but what it starts can, so treat it as a sending node when choosing which environment key the connection holds. Release a digest now instead of waiting for its schedule, so every user with something accumulated receives it immediately. That is a real send per waiting user, which makes the blast radius the size of the digest's audience rather than one. Use it when something has changed that makes the collected notifications urgent. Courier answers 204 whether or not anything was waiting, so a success here does not prove anything went out.
Courier: Remove User from Tenant
Remove one user from one tenant, so tenant-scoped sends stop reaching them and their tenant-specific profile no longer applies. The offboarding counterpart to Courier: Add User to Tenant. Deliberately narrow: their other tenant memberships and their workspace-level profile and preferences are separate resources and survive, so this is not an erasure.
Courier: Replace Preference Topic
Replace a subscription topic in full. Every optional field you omit is CLEARED rather than left alone, so a call sending only name and default_status drops the routing options, the allowed preferences and the unsubscribe header setting with it. Read the topic with Courier: Get Preference Topic first and send back what you meant to keep. Changing default_status changes what happens to everyone who has never set a preference, which can be most of the audience.
Courier: Replace Profile
Overwrite a user's profile in full. Any key absent from the body is REMOVED, so a call carrying only an email address deletes the stored phone number and every custom field with it, and the next SMS to that person is UNROUTABLE. Reach for Courier: Create or Merge Profile unless replacing the whole record is the actual intent, such as reseeding from a system of record. List subscriptions and preferences live outside the profile and are not affected.
Courier: Replace User Preferences in Bulk
Replace a user's ENTIRE set of preference overrides. Every topic absent from the body is reset to its default, and an empty array wipes every override the person has, which re-subscribes anyone whose topics default to opted in. The response even lists what it removed under deleted. Use this only when the body genuinely is the complete intended state, such as reseeding from a system of record. For a preference centre or any partial update the correct node is Courier: Update User Preferences in Bulk. Up to 50 topics.
Courier: Resend Message
SENDS FOR REAL. This node delivers to live destinations and spends the workspace's notification quota, so a test run reaches a real inbox, phone or device. Use a Courier TEST environment key while building: Courier scopes keys per environment and a test key never sends real notifications. Resend a previously sent message to the same recipient with the same content, returning a NEW messageId. The original is not modified, so this is a genuine second delivery and a second unit of quota, not a status change. Not every message supports it: Courier answers 400 saying so. There is no idempotency key on this endpoint, so a retried workflow step sends twice.
Courier: Run Bulk Job
SENDS FOR REAL. This node delivers to live destinations and spends the workspace's notification quota, so a test run reaches a real inbox, phone or device. Use a Courier TEST environment key while building: Courier scopes keys per environment and a test key never sends real notifications. Start a bulk job, sending to every user ingested into it. This is the step that spends quota, and it spends it once per recipient in the batch. Courier answers 204 immediately and processes asynchronously, so a success here means started and not finished: poll Courier: Get Bulk Job for status and counts. There is no documented way to stop a job once it is running, so check the recipient count with Courier: List Bulk Job Users before this node rather than after.
Courier: Schedule Broadcast
SENDS FOR REAL. This node delivers to live destinations and spends the workspace's notification quota, so a test run reaches a real inbox, phone or device. Use a Courier TEST environment key while building: Courier scopes keys per environment and a test key never sends real notifications. The send happens later rather than now, which makes it easier to miss in testing, not safer. Courier publishes the broadcast's draft content at SCHEDULE time, so editing the draft afterwards does not change what goes out. The timestamp is wall clock with NO offset (2026-07-21T20:00:00) and the zone comes from the separate timezone field, so a value carrying a Z or an offset is not what this endpoint expects. Reverse it with Courier: Cancel Broadcast Schedule while it is still scheduled.
Courier: Send Broadcast
SENDS FOR REAL. This node delivers to live destinations and spends the workspace's notification quota, so a test run reaches a real inbox, phone or device. Use a Courier TEST environment key while building: Courier scopes keys per environment and a test key never sends real notifications. It is also the widest blast radius in this connector: one call delivers to every member of a list or audience, and Courier publishes the broadcast's draft content first, so whatever is in the draft is what goes out. There is no recall. Confirm the recipient count with Courier: List List Subscriptions or Courier: List Audience Members before this node runs. Not permitted once the broadcast is sending or sent, which answers 409.
Courier: Send Message
SENDS FOR REAL. This node delivers to live destinations and spends the workspace's notification quota, so a test run reaches a real inbox, phone or device. Use a Courier TEST environment key while building: Courier scopes keys per environment and a test key never sends real notifications. Send one logical notification to one or more recipients and let Courier route it to email, SMS, push, chat or the in-app inbox according to the routing rules, the recipient's stored profile and their preferences. This is the node the whole connector is built around: you describe WHAT to say and WHO to say it to, and Courier decides which channels that person actually accepts. Give it either a template id (the normal case, so copy stays in Courier's editor) or inline content. The response is a 202 with a requestId, which means accepted and NOT delivered: follow it with Courier: List Messages or Courier: Get Message to learn what happened. Set an idempotency key on any send a workflow might retry.
Courier: Set Tenant Default Preference
Set a tenant's default opt-in status and channels for ONE subscription topic, which applies to every member who has not set their own override. Narrower and safer than Courier: Create or Replace Tenant, because it leaves the tenant's other defaults, properties and profile alone. It is still a many-person write: it takes effect immediately, with no confirmation, for everyone in the tenant. It is the right tool for an administrator turning a category on for their whole organization, and the wrong tool for anything an individual should control, which is Courier: Set User Topic Preference.
Courier: Set User Topic Preference
Set one user's opt-in status and channel choices for one subscription topic, creating the override if they had none. This is the node behind an unsubscribe link, a preference centre toggle and a compliance request, and it is the correct way to honour someone asking to stop receiving a category of notification: it survives list changes and applies to every send about that topic. Scoped to this topic only, so nothing else the person receives changes. Courier REFUSES to opt a user out of a topic whose default_status is REQUIRED, which is how transactional messages stay deliverable.
Courier: Subscribe User to List
Subscribe one user to one list, creating the list if it does not exist. The single-recipient counterpart to Courier: Add List Subscribers, and the right node when a workflow is reacting to one person's action. Optional preferences apply to this subscription only and do not change the user's workspace-level preferences.
Courier: Subscribe User to Lists
Subscribe one user to several lists in one call, creating any list that does not yet exist. This is the signup-time node: one write puts a new user on the product-updates, billing and security lists at once. Optional per-subscription preferences let the same call record what they agreed to. Reverse a single membership with Courier: Unsubscribe User from List.
Courier: Track Event
MAY CAUSE A REAL SEND. This node does not deliver anything by itself, but what it starts can, so treat it as a sending node when choosing which environment key the connection holds. Record an inbound event that Courier journeys and automations can trigger on. This is the event-driven alternative to invoking a journey by id: your system reports that something happened and Courier decides which sequences care. The event name is what appears in the trigger node of a journey, so it should read like a fact about your product rather than like a notification. The messageId is a deduplication key you generate: reuse one and Courier answers 409 Conflict rather than double-triggering, which makes this node safe to retry.
Courier: Unsubscribe User from List
Remove one user's subscription to one list. This is the unsubscribe node for list-based sends, and it is narrow on purpose: the user's profile, their other list subscriptions and their topic preferences are all separate resources and are untouched. If the intent is honouring an unsubscribe request for a whole category of notification, the correct node is Courier: Set User Topic Preference, because that is what a preference centre and an unsubscribe header actually control.
Courier: Update User Preferences in Bulk
Create or update a user's preferences for several topics at once, leaving any topic you do not mention exactly as it was. This is the safe bulk write and the one a preference centre should post: the form submits the toggles it rendered and nothing else moves. Between 1 and 50 topics per call. Failures are per topic and come back in an errors array rather than rolling the whole call back, so check it rather than trusting the 200.
Connecting Courier takes one credential
Create and rotate keys in Courier under Settings and then API Keys. Before you copy one, read which environment it belongs to. Every Courier workspace has a Production environment and a Test environment, and Courier states that the two are fully isolated: templates, brands, tags, subscription topics, provider integrations, API keys and log data all belong to one environment only, and assets move between them through Courier's migrate assets feature rather than automatically. A key is scoped to a single environment, and Courier's API overview puts the consequence plainly, that a Test key never sends real notifications and a Production key is never used for experiments. Courier's environments documentation adds the qualification worth knowing before you rely on it: test sends appear only in the Test dashboard and never reach real users unless you use real contact information. So a Test key is the right credential to build against, and a test profile with a real personal phone number in it is still a real text message. Business plans additionally offer a mock key, which Courier describes as simulating the full notification lifecycle without invoking the downstream provider. Two practical consequences of the isolation: the template ids, topic ids and brand ids you pick in a workflow built against a Test key are not the ids that exist in Production, and a workspace that connects a Production key first gets production behaviour from the very first test run.
Decide which environment this connection is for, and create two connections rather than one if you can. A Test key for the workspace where automations are built and an eventual Production key for the workspace where they run is the whole safety model, because no node setting can substitute for it.
In Courier, open Settings and then API Keys, confirm the environment selector shows Test, and copy the key for that environment.
In Mattering Automations, open Connectors, click Add Connector and choose Courier, then create a new credential and paste the key into the single API key field. It is stored encrypted and never appears in workflow logs.
Click Test Connection. Mattering calls the brands endpoint, which takes no parameters, is present in every workspace because Courier creates a default brand, and cannot send anything. A rejected key answers an ordinary 401.
All 80 Courier nodes appear in the canvas palette. Start with Courier: List Preference Sections, which returns the entire catalog of subscription topics this workspace can notify people about in one call, and is the picker source behind every topic id field in the connector.
Before you wire a send, run Courier: List Providers to confirm which channels this environment can actually deliver on. A message that resolves to a channel with no configured provider comes back UNROUTABLE, and this is the node that explains it. The provider settings objects are blanked by the connector, because that is where the workspace's SendGrid, Twilio and Firebase credentials live.
When you promote the workflow, swap the credential rather than the nodes, and set an idempotency key on every send that a retry could duplicate. Courier accepts an Idempotency-Key header on its POST endpoints, caches the first response for that key and replays it for 24 hours, and the connector exposes it as a config field on the nodes whose endpoint documents it.
Common uses for the Courier MCP
A send an agent can be trusted with, because it checks the choice first
The pattern that makes Courier worth automating is read the preference, then send. Courier: Get User Topic Preference returns one person's opt-in status and channel choices for one subscription topic, or the effective default if they have never expressed one, and it returns status alongside default_status so a workflow can distinguish a deliberate opt-in from silence. A condition on that field, then Courier: Send Message with a template id, is a send that respects a choice the recipient actually made rather than one the sender assumed. Give an assistant the preference reads and keep the send behind the condition, and the worst outcome of a confused agent is a query rather than an unwanted message.
Signup, unsubscribe and everything that keeps the directory current
This is the half of Courier that changes at run time, and it is covered in full. Courier: Create or Merge Profile writes an email address, a phone number or a custom field without touching the keys you left out, which is the everyday write. Courier: Subscribe User to Lists puts a new account on the product updates, billing and security lists in a single call at signup. Courier: Set User Topic Preference is the node behind an unsubscribe link or a preference centre toggle, and Courier: Unsubscribe User from List is its list-based counterpart, narrow on purpose so it leaves the person's profile and other subscriptions alone. Courier: Add User Device Token and Courier: Delete User Device Token are what an app calls at login and logout so push sends stop targeting a device nobody holds any more. Watch the replace variants: Courier: Replace Profile removes any key absent from the body, so a call carrying only an email address deletes the stored phone number and the next SMS has nowhere to go.
Delivery triage that answers why a person did not get it
A 202 from a send means accepted, not delivered, and Courier's own reference says to use the returned request id to look up delivery status through the Messages API. Courier: List Messages is that log, filterable by recipient, notification, status or tag, and the statuses that mean trouble are UNROUTABLE, where no channel could be resolved, UNDELIVERABLE, where the provider rejected the address, and UNMAPPED, where the template was not found. Courier: Get Message History gives the ordered path a single message took rather than only where it ended up, and Courier: Get Message Content returns what the recipient actually saw after variables were interpolated and the brand applied. Chain that into a support workflow and the answer to did they get it stops being a guess.
A large batch send that does not depend on the workflow surviving
Looping single sends over ten thousand rows makes the run's completion the thing that determines whether people get their message. The bulk flow moves that server side. Courier: Create Bulk Job opens the job with the message definition and delivers nothing, Courier: Add Bulk Job Users feeds recipients in as many calls as the batch needs, and only Courier: Run Bulk Job starts it, which is where the SENDS FOR REAL warning sits. Courier: Get Bulk Job then reports the counters, and Courier: List Bulk Job Users shows the ingested set with the message id each recipient produced. The review step is the point: you can inspect exactly who is in the batch before anything goes out, which is not true of a loop.
Per-customer notification defaults for a multi-tenant product
A Courier tenant is an organization, team or account your users belong to, carrying a brand, a user profile merged into every member on send, and default preferences that govern what every member receives absent a personal override. Courier: Add User to Tenant and Courier: Remove User from Tenant are the invite-accepted and offboarding writes. Courier: Set Tenant Default Preference turns one notification category on or off for every member who has not set their own override, which is the right tool for an administrator configuring their organization. Two cautions the nodes state rather than leave to be found: Courier: Create or Replace Tenant is a PUT and it replaces, so sending a name without default_preferences clears them for everybody in that tenant, and Courier: List Tenant Users exists partly so a workflow can size that blast radius before making either write.
Charting whether a notification is actually working
Courier: Get Template Metrics is the connector's one reporting endpoint: a time series of sent, delivered, opened, clicked, errors and undeliverable for a single template, broken out per provider and channel inside each bucket. Two behaviours change what a chart should plot. There is no bucket-level total, so the entries inside a bucket have to be summed for one, and the window is snapped outwards onto the granularity grid with the snapped bounds returned in the response, so align a chart on those rather than on what was requested. Every bucket comes back including the empty ones, so no gap filling is needed. Read the plan gate before scheduling a backfill: an over-long range answers 402 rather than 400, the free Developer lookback is 30 days, and the endpoint is available in the United States region only.
Example: A service alert that respects the recipient's choice and proves what happened
Built on the Automations canvas in a few minutes, or described in plain language to Matter and built for you.
Trigger: a monitoring webhook or a scheduled check fires inside Mattering Automations. This connector has no trigger nodes, so Courier is the thing being driven rather than the thing listening.
Courier: Get User Topic Preference reads the affected person's status for the service alerts topic. The node returns status and default_status separately, so the workflow can tell an explicit opt-in from a person who has simply never chosen.
A condition branches on that value. If the person has opted out and the topic is not REQUIRED, the workflow stops here and records why, which is the branch that keeps an automated sender out of trouble.
Courier: Send Message sends one logical notification with a template id and lets Courier route it to email, SMS, push, chat or the in-app inbox according to that recipient's profile and preferences. An idempotency key generated from the incident id makes a retry safe, because Courier replays the first response for 24 hours instead of sending twice.
A short wait, then Courier: Get Message reads the outcome using the request id the send returned. A 202 was only an acceptance, so this is the step that turns it into a fact.
If the status is UNROUTABLE, Courier: List Providers answers the usual cause by naming which channels this environment can actually deliver on, and a Mattering Productivity task is opened for a person rather than the alert being retried into the same wall.
Build the whole thing with a Test environment credential attached, and swap the credential rather than the nodes when it is ready to run for real.
Courier MCP questions, answered
What can this connector actually do in Courier?
80 nodes: 41 read and 39 act. Sending covers a single send, the four call bulk flow, sending and scheduling a broadcast and cancelling its schedule, invoking a journey or a v2 automation, cancelling journey runs, cancelling and resending a message, releasing a digest and tracking an inbound event. Reading covers the delivery log with per-message status, history and rendered content, journey and automation run logs down to per-step state, bulk job counters, and the audit log. The recipient directory covers user profiles, list membership on both sides, push device tokens and tenant membership. Preferences cover the topic catalog, single topic reads and writes, both bulk forms and the hosted preference page publish. Catalogs cover lists, templates, brands, tenants, routing strategies, audiences, providers, journeys, automations and broadcasts. Not included, and worth knowing before you plan: template and journey authoring, Elemental content and locale overrides, tenant templates, translations, brand and routing strategy documents, broadcast creation, and provider configuration. Also not included, deliberately, is the PUT form of list subscriptions, which overwrites the entire subscriber set and silently unsubscribes everyone not named in the body. All of it stays reachable through Courier: API Request, an advanced node that calls any Courier API endpoint directly.
Does Courier publish its own MCP server?
Yes. Courier ships a hosted MCP server at mcp.courier.com, authenticated with the same API key, and its own tutorials point at it for sending from an AI agent and for managing templates from the CLI. It exposes a larger tool count than this connector's node list, so on raw API coverage it wins and we are not going to pretend otherwise. The reasons to use this connector instead are about what surrounds the call. These nodes run unattended on a schedule or off another system's event, not only inside a chat session. They chain with every other connector on one canvas, so a form submission, a database write and a Courier send are steps in one workflow rather than three separate integrations. The API key sits once in a shared workspace credential store rather than in each person's local MCP config file, which also means rotating it is one action. And the nodes that can put a message in front of a real person are flagged destructive and say so in the first line of their own description, which matters more on Courier than on most connectors, because a mistaken send cannot be undone.
Can an AI agent send a Courier notification, and does this work with Claude or ChatGPT?
Yes to both, with a caveat worth taking seriously. Mattering exposes these nodes over MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT and any MCP-capable assistant can work with Courier through your workspace, and Matter, the assistant built into the platform, uses the same nodes natively. The caveat is that nine of the 80 nodes can cause a real message to arrive at a real person, so the sensible split is to give an assistant the read nodes and the preference reads freely, and to put the sending nodes behind a condition, an approval step or a Test environment credential. An agent that can list messages, read a preference and explain why a notification did not arrive is useful and harmless. An agent holding Courier: Run Bulk Job against a production key is a different proposition.
Will connecting this send real notifications to real people?
It can, and that is the most important thing on this page. Seven nodes open their description with SENDS FOR REAL: send message, send broadcast, schedule broadcast, run bulk job, invoke journey, invoke automation and resend message. Two more open with MAY CAUSE A REAL SEND, because they start something that delivers rather than delivering themselves: track event, which is what a journey trigger listens for, and release digest, which flushes every waiting user's accumulated notifications at once and answers 204 whether or not anything went out. The only real control is the credential. Courier scopes API keys to a single environment, Test or Production, and its API overview states that a Test key never sends real notifications while a Production key is never used for experiments. Its environments documentation qualifies that usefully: test sends appear only in the Test dashboard and never reach real users unless you use real contact information, so a test profile carrying somebody's actual mobile number is still an actual text message. Build against a Test key, keep in mind that the two environments are fully isolated so template and topic ids differ between them, and swap the credential when the workflow is ready.
Do I need a paid Courier plan for any of this?
No. Courier's Developer plan is free, includes 10,000 sends per month, and includes API access along with the SDKs and CLI, so the free tier meters sends rather than switching features off. One plan gate exists and the connector names it on the node: Courier: Get Template Metrics answers HTTP 402 payment required when the requested range exceeds the plan's maximum lookback, which Courier documents as 30 days on Developer and 90 days on Business. A 402 arriving where a workflow expects a 400 is worth designing around, because chunking logic usually reads it as a transport failure rather than as a signal to ask for less. That endpoint also carries its own per second request limit that varies by plan, and it is available in the United States region only.
Why does this connector cover preferences so heavily and template content not at all?
Because coverage should follow how often a workflow touches something, not how many endpoints a vendor wrote. Subscription topics and user preferences change constantly at run time: at signup, at unsubscribe, when somebody flips a toggle, and immediately before a send that has to respect a choice. Template content is authored once in Courier's editor by a person looking at a preview and referenced by id forever after, and an element by element replace API is something an editor calls, not a workflow. So all six user preference operations ship, along with the topic catalog and the hosted preference page publish, while template content, Elemental elements and locale overrides are left in Courier where they are designed. The template nodes that do ship are the ones a workflow uses: listing templates to find one, reading one, and reading its delivery metrics. If you genuinely need to publish a template from an automation, Courier: API Request reaches it.
What are Courier's rate limits?
Courier documents per minute limits on specific management endpoints rather than a single account wide number. Its API reference lists 20 requests per minute on the list subscriptions endpoint, on updating a list and on the events endpoint, and 200 requests per minute on brands. The send endpoint is not among the endpoints carrying a documented per minute limit; what bounds it in practice is the 6 MB request body cap, which answers 413, and whatever send volume your plan and workspace allow. The template metrics endpoint carries its own per second limit that varies by plan. Two design habits follow from that shape. Prefer the bulk flow over a loop of single sends for a large batch, because Courier enqueues the whole thing server side. And where an inline attachment is involved, remember that base64 inflates by about a third, so anything above roughly 4.5 MB of raw bytes needs to be hosted and sent as a URL.
What happens if a workflow overwrites or deletes the wrong thing?
The connector separates the additive writes from the replacing ones and labels them by exactly that difference, because the difference is invisible in an endpoint name. Courier: Create or Merge Profile leaves keys you omit alone while Courier: Replace Profile removes them. Courier: Update User Preferences in Bulk leaves unmentioned topics alone while Courier: Replace User Preferences in Bulk resets them to their default, and an empty topic list wipes every override the person has, which re-subscribes anyone whose topics default to opted in. Courier: Create or Replace Tenant replaces, so omitting default_preferences clears them for every member of that tenant. Two deletes ship and both say what they cost: Courier: Delete Profile is permanent with no undelete documented, and Courier: Delete List halts any send targeting that list immediately, though Courier keeps the list and its subscribers and can restore both through an endpoint reached by way of the passthrough. The most dangerous operations in the API are not on the palette at all: deleting a tenant, removing a user from every tenant, and the PUT form of list subscriptions were all cut because their fallout is invisible from the call site, and reaching them requires a deliberate configuration of Courier: API Request rather than one click below the node that reads them.
Put Courier to work inside your workspace
Connect once, then use every node in visual automations and AI agent workflows across the Mattering platform.
All product names, logos, and brands are property of their respective owners and are used for identification purposes only. Use of these names, logos, and brands does not imply endorsement or affiliation. Courier is a product of its respective owner; Mattering is an independent platform.