Menu

Mattering Automations Courier integration

Connect Courier to Mattering Automations: multi-channel sending, bulk jobs, broadcasts, journeys, the delivery log, user profiles, lists, device tokens, tenants and the full subscription preference model as workflow steps, authorized by one API key whose environment decides whether real notifications go out.

The Mattering Automations Courier integration puts Courier's notification API on your automation canvas: send one logical message and let Courier route it to email, SMS, push, chat or the in-app inbox; run bulk jobs and broadcasts; start journeys and v2 automations and read their runs; follow every send through the delivery log with per-provider status; keep user profiles, list membership, device tokens and tenant membership current; and read and write the subscription preferences that decide what each person actually receives. Eighty nodes in total, forty one that read and thirty nine that act.

The credential is one API key, sent as an Authorization bearer token against a single global host. There are no scopes to choose and no refresh to manage. There is one decision that matters, and it is which environment the key belongs to. Courier scopes every key to either Production or Test, and that choice, not any node setting, is what determines whether building this workflow puts real messages in front of real people.

Read the sending section below before you connect anything. Seven nodes in this integration open their own description with the words SENDS FOR REAL, and two more warn that they may cause one. That is unusual for a connector and it is the honest shape of a notification API: Courier: Send Message exists to deliver something to somebody. Everything else in this guide, including the Test Connection probe and the verify steps, is built so that you can confirm the connection works without sending anything at all.

Before you start

  • A Courier account. The free Developer plan is enough: Courier lists it at no cost with 10,000 sends per month and API access included, alongside the SDKs and CLI, so the free tier meters sends rather than switching features off.
  • An API key from the environment you intend to build against. Open Courier's Settings and then API Keys and note which environment the key belongs to before copying it. For building and testing, that should be Test.
  • An understanding that the Test and Production environments are fully isolated. Courier states that templates, brands, tags, subscription topics, provider integrations, API keys and log data all belong to one environment only, and that assets move between them through its migrate assets feature. The template ids, topic ids and brand ids a workflow references in Test are not the ids that exist in Production.
  • At least one configured provider integration in that environment, if you intend to send. Courier decides which channel a message goes out on, and a channel with no provider configured behind it produces an UNROUTABLE message rather than an error at the send call. Courier: List Providers answers what this environment can deliver on.
  • At least one published notification template, if you intend to send by template id, which is the normal case. Courier's own MCP documentation notes that templates default to draft and that sending with a template id which has never been published returns an error.
  • For Courier: Get Template Metrics specifically, an awareness that the requested range is plan-gated: Courier documents a maximum lookback of 30 days on Developer and 90 days on Business, and answers HTTP 402 rather than 400 when a request exceeds it. That endpoint is also available in the United States region only.
  • A Mattering workspace with access to the Automations app.

Create a Courier API key, in the right environment

Courier authenticates with a single API key sent as Authorization: Bearer, so the credential form here has one field. Almost all of the care in this step goes into which key you copy rather than where you paste it, because Courier scopes keys per environment and the environment is the only thing standing between an automation under construction and a real notification arriving at a real person.

Sign in to Courier and open Settings and then API Keys.
Check the environment selector before you copy anything. Every workspace has a Production and a Test environment, and the key list you are looking at belongs to exactly one of them.
Copy the key for the Test environment while you are building. Courier's API overview states that a Test key never sends real notifications and that a Production key is never used for experiments.
Courier's environments documentation adds a qualification worth respecting: test sends appear only in the Test dashboard and never reach real users unless you use real contact information. A test profile carrying a colleague's real mobile number will still produce a real text message. Use obviously fake contact details in test profiles, or a mailbox and number you control.
The two environments are fully isolated. Templates, brands, tags, subscription topics, provider integrations, API keys and log data belong to one environment only, and Courier moves them between environments through its migrate assets feature. Expect template ids, topic ids and brand ids to differ, so plan to swap those alongside the credential when a workflow is promoted.
Business plans additionally offer a mock key, which Courier describes as simulating the full notification lifecycle without invoking the downstream provider, so a request can be watched flowing through Courier without incurring a send cost.
Rotate keys from the same screen. Because the key is held once in the Mattering credential rather than in each person's local configuration, rotating it means updating one credential rather than hunting for copies.

Connect Courier to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Courier from the list.
Click Create new credential and paste the API key into the single API Key field. Name the credential after its environment, for example Courier Test, so that nobody has to guess later which one a workflow is attached to.
The key is stored encrypted in Google Secret Manager and never appears in workflow logs or node outputs.
Click Test Connection. Mattering calls Courier's brands endpoint, which takes no parameters, exists in every workspace because Courier creates a default brand, and cannot deliver anything. A rejected key answers an ordinary HTTP 401 carrying a message and a type.
All 80 Courier nodes appear in your canvas palette, grouped as 41 reads and 39 actions.

Verify it works

Drop Courier: List Brands onto a canvas and run a test step. This is the same call Test Connection makes, and it is the natural first probe because it is parameter-free, cheap and present in every workspace. A successful response proves the key, the header wiring and the environment reachability in one request without touching a recipient.

Now run Courier: List Preference Sections. It returns the workspace's preference sections with their subscription topics embedded, so one call gives you the entire catalog of things this workspace can notify people about. This is the node worth confirming early for two reasons: it is the picker source behind every topic id field in the integration, and its output is the first place the environment isolation becomes visible, because a Test environment's topics are its own rather than Production's.

Finish with Courier: List Providers and Courier: List Messages. The first answers which channels this environment can actually deliver on, which is the usual explanation for an UNROUTABLE message later. The second reads the delivery log, which on a fresh Test environment is legitimately empty. Every step in this verify path is read-only, so none of it sends anything, spends send quota or touches a recipient, and it can be re-run whenever you want to check the connection.

Node reference

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

Read and query nodes 41

Courier: Get Audience

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

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

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

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

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

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

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

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

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

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

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

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

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

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

courier_get_user_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

courier_get_user_lists

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

courier_list_user_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

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

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

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

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

courier_add_user_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

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

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

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

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

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

courier_create_user_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

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

courier_create_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

courier_update_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

courier_update_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

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

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

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

courier_delete_user_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

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

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

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

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

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

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

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

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

courier_replace_user_preferences

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

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

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

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

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

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

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

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

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

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

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

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

courier_update_user_preferences

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.

Using the integration

The nine nodes that can reach a real person

This is the section to read before anything else. Seven nodes open their own description with SENDS FOR REAL, because they deliver to live destinations and spend the workspace's send quota: Courier: Send Message, Courier: Send Broadcast, Courier: Schedule Broadcast, Courier: Run Bulk Job, Courier: Invoke Journey, Courier: Invoke Automation and Courier: Resend Message. Two more open with MAY CAUSE A REAL SEND, because they start something that delivers rather than delivering themselves. Courier: Track Event records an inbound event that journeys and automations trigger on, so whether it sends depends on what is configured to listen. Courier: Release Digest flushes every waiting user's accumulated notifications immediately instead of waiting for the schedule, which makes its blast radius the size of the digest's audience rather than one person, and Courier answers 204 whether or not anything was actually waiting, so a success here does not prove anything went out. All nine are ordinary nodes with no hidden confirmation step, and the integration cannot add one, because the only real control is which environment key the credential holds. Build with a Test key, wire the workflow, and swap the credential rather than the nodes when it is ready.

Sending, and why a 202 is not a delivery

Courier: Send Message is the node the integration is built around. You describe what to say and who to say it to, either with a template id, which is the normal case so that copy stays in Courier's editor, or with inline content, and Courier decides which channels that person actually accepts based on the routing rules, their stored profile and their preferences. What comes back is an HTTP 202 and a request id, and Courier's own reference is explicit that this means accepted rather than delivered, with the request id being what you use to look up delivery status afterwards. So a workflow that treats a successful send node as proof of delivery is wrong in a way that only shows up when somebody complains. Follow it with Courier: Get Message or Courier: List Messages. Set an idempotency key on any send 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 integration exposes it as a config field on the nodes whose endpoint documents it. That matters most where a workflow is triggered by something outside your control, because a retried form submission without a key is a duplicate notification.

The preference model, which is the reason to use Courier at all

Twelve nodes cover preferences and none cover template content, and the asymmetry is deliberate. Courier's value is routing one logical notification across channels according to what each recipient agreed to receive, and a workflow touches those objects constantly while template content is authored once and referenced by id forever. Three facts are worth knowing before writing any of it. First, resolution runs from the user's own override, then the tenant default, then the topic default, and Courier: Get User Topic Preference returns the person's status alongside default_status precisely so a workflow can tell an explicit opt-in from somebody who has never chosen and simply inherited an opt-in default. Those look identical if you read one field and mean opposite things at unsubscribe time. Second, REQUIRED is a topic-level default set in the preferences editor rather than a user choice, which is how transactional notifications stay deliverable and why a preference write can fail for a reason nothing in the request explains. Third, the two bulk writes differ only in what happens to topics you did not mention: Courier: Update User Preferences in Bulk leaves them exactly as they were, while Courier: Replace User Preferences in Bulk resets them to their default, and an empty topic array wipes every override the person has, which re-subscribes anyone whose topics default to opted in. Both ship, labelled by that difference, because sending the wrong one silently undoes somebody's unsubscribe. Courier: List Preference Sections returns the whole catalog with topics embedded in one call, and Courier: Publish Preferences Page is what makes topic changes visible to recipients on the hosted preference page.

Tenants, and the writes that reach past the record you are editing

A Courier tenant is an organization, team or account that users belong to, and it carries three things that apply to everybody inside it: a brand that styles every send in its context, a user profile merged into every member's profile at send time, and default preferences that decide what every member receives unless they have set their own override. Two writes therefore have a blast radius larger than the call looks. Courier: Create or Replace Tenant is a PUT and it replaces: sending a name without 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 omitted from one call, so read the tenant with Courier: Get Tenant, merge, then write. Courier: Set Tenant Default Preference is the narrower and safer tool when only one topic needs changing, though it still applies immediately to every member without a personal override, which makes it right for an administrator turning a category on for their organization and wrong for anything an individual should control. Courier: List Tenant Users exists partly so a workflow can size that blast radius before either write. Membership itself is ordinary: Courier: Add User to Tenant and Courier: Remove User from Tenant are the invite-accepted and offboarding nodes, and Courier: List User Tenants answers which contexts one person belongs to.

Bulk, broadcasts and journeys, and which step is the one that fires

Three different ways to reach many people at once, each with exactly one node that actually sends. Bulk is four calls in order: Courier: Create Bulk Job opens the job with the message definition and delivers nothing, Courier: Add Bulk Job Users feeds recipients in as many times as the batch needs, Courier: Run Bulk Job starts it, and Courier: Get Bulk Job reports the received, enqueued and failure counters afterwards. Only the run step sends, which means Courier: List Bulk Job Users gives you a genuine review of exactly who is in the batch before anything goes out, something a loop of single sends cannot offer. Broadcasts are authored in Courier and fired by id from here: Courier: Send Broadcast and Courier: Schedule Broadcast are the fire verbs, Courier: Cancel Broadcast Schedule is the only way to stop a scheduled campaign from the API and is valid only while it is still scheduled, and Courier: Get Broadcast is worth calling first because Courier refuses to send a broadcast that is already sending or sent. Journeys are multi-step sequences built in Courier's editor: Courier: Invoke Journey starts one, Courier: Cancel Journey Runs stops runs still in flight, which is what turns a multi-day nudge sequence off when the thing it was nudging about has happened, and Courier: List Journey Runs, Courier: Get Journey Run and Courier: List Journey Run Steps are the operational view, the last of them showing which branch a run took and where it is waiting.

Reading the delivery log, and the three shapes of pagination

Courier: List Messages is the log every delivery question ends at, filterable by recipient, notification, status, tag or trace. 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, and each carries a reason such as BOUNCED or UNSUBSCRIBED alongside it. Courier: Get Message History gives the ordered path a message took rather than only its current state, and Courier: Get Message Content returns what the recipient actually saw after variables were interpolated and the brand applied, which is the node that settles arguments about wording. Two conventions catch people out. Timestamps are epoch milliseconds on the older surfaces including messages, templates, brands, providers and routing strategies, and ISO 8601 strings on the newer ones including journeys, automations, broadcasts, audiences, lists and audit events, and the sample outputs on each node mirror what Courier really returns rather than a tidied version. And cursor pagination comes in three shapes: most endpoints answer with a paging object carrying more and cursor, journey and automation runs return a flat next_cursor with rows under runs and no more flag at all, and tenants return a top-level cursor with has_more. Every list node names its own shape in its description, because a loop written against paging.more never terminates on a runs endpoint.

What is not included, and the node that reaches it anyway

Seventy nine of Courier's 155 documented operations ship as named nodes, with an eightieth node reaching the rest, and the exclusions follow one rule: authoring surfaces stay in Courier, where a person designs them while looking at a preview. That means template content, Elemental elements, locale overrides and template submission checks; journey graphs, journey publishing and journey-scoped templates, which is the single largest cut; broadcast creation, duplication and content; brand styling documents and routing strategy rule documents; tenant templates; and translations, which are a build-time asset job uploaded per domain and locale rather than something a notification workflow touches. Provider configuration is cut for a different reason, which is that creating or updating a provider means posting the workspace's SendGrid, Twilio or Firebase credentials through node config. The lister that does ship, Courier: List Providers, blanks every settings object on the way out for the same reason. Three destructive operations were also kept off the palette because their fallout is invisible from the call site: deleting a tenant, which takes its members' tenant-scoped profiles and preferences with it; removing a user from every tenant at once; and the PUT form of list subscriptions, which shares a URL with the additive POST and silently unsubscribes everyone not named in the body. None of that is unreachable. Courier: API Request is an advanced node that calls any Courier API endpoint directly with the connection's credential applied, taking a method, a path, a query object and a body object. It is flagged destructive and treated as a sending node, because nothing stops a caller pointing its path at the send endpoint, and its path is refused rather than normalised if it does not begin with a single slash, so a full URL cannot redirect the workspace's credential to another host. Prefer a named node whenever one exists.

Metrics, and the one plan gate in the integration

Courier: Get Template Metrics is the only reporting endpoint here: a time series of sent, delivered, opened, clicked, errors and undeliverable for one notification template, broken out per provider and channel inside each bucket. Four behaviours change what a chart should plot. There is no bucket-level total, so the entries within a bucket must be summed to get one. The window is snapped outwards onto the granularity grid and the snapped bounds come back as the response's own start and end, so align a chart on those rather than on what was requested. Every bucket in the window is returned including the empty ones, so no client-side gap filling is needed. And every boundary is UTC with no timezone support. Two limits sit on top. The maximum span depends on the granularity you asked for, with HOUR capped at 7 days and DAY at 90 while WEEK and MONTH are bounded instead by a 1000 bucket response limit. And the lookback is plan-gated, which no other node here is: exceeding the plan's maximum lookback returns HTTP 402 payment required rather than a 400, and Courier documents that ceiling as 30 days on Developer and 90 days on Business. A backfill that chunks its way through a year will therefore fail on billing rather than on validation, which most retry logic reads as a transport error. The endpoint is available in the United States region only, an unknown template id returns an all-empty series rather than a 404, and messages sent without a template never appear in it at all.

From AI assistants over MCP, and Courier's own MCP server

Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT and any MCP-capable assistant can drive this integration through your workspace, alongside Matter, the assistant built into the platform. Courier also publishes its own hosted MCP server at mcp.courier.com, authenticated with the same API key, and its tutorials point at it for sending from an agent and for managing templates from the CLI. It exposes a larger tool count than this node list, so if what you want is a send tool inside a local assistant configuration, use it. What this integration adds is the platform around the same API: the nodes run unattended on a schedule or off another system's event rather than only inside a chat session, they chain with every other connector on one canvas, the key is held once in a shared workspace credential store rather than in each person's own config file, and the nodes that can reach a real person carry destructive flags and written warnings. Given that last point, the sensible split when handing this to an assistant is the 41 read nodes and the preference reads freely, with the sending nodes behind a condition, an approval step, or a Test environment credential.

On the automation canvas

Courier nodes chain with everything else in Mattering. A form submission can run Courier: Create or Merge Profile and then Courier: Subscribe User to Lists so a new account lands on the right lists in one write. An unsubscribe link handler can call Courier: Set User Topic Preference or Courier: Unsubscribe User from List, the latter deliberately narrow so it leaves the person's profile and other subscriptions untouched. A mobile app's login and logout can call Courier: Add User Device Token and Courier: Delete User Device Token so push stops targeting devices nobody holds. A scheduled workflow can read Courier: Get Template Metrics into a Mattering database and open a Productivity task when open rates fall. And a support workflow can answer whether a customer received something by reading Courier: List Messages rather than guessing. This connector has no trigger nodes, so Courier is the system being driven here rather than the one listening: workflows run on a schedule or off a trigger from another connector, and Courier: Track Event is how you push an event into Courier for its own journeys to react to, not how Mattering hears about one.

Troubleshooting

Test Connection fails with a 401
Courier answers an ordinary HTTP 401 with a message and a type when a key is not valid, so this is the credential itself rather than a permission or a region. Three causes account for almost all of them. The key was copied with surrounding whitespace or truncated, which is easy to do from the Courier settings screen. The key was rotated or revoked in Courier after the credential was created. Or the key belongs to a workspace that has since been changed. Paste a fresh key from Courier's Settings and then API Keys screen and test again. Note what a 401 does not mean here: there are no scopes on a Courier key, so a working key that fails on one specific node is not a permission problem and should be read as a request shape or plan issue instead.
A test run sent a real notification to a real person
The credential holds a Production key. Courier scopes API keys to a single environment and states that a Test key never sends real notifications while a Production key is never used for experiments, and nothing in a node can override that, which is why seven nodes carry a SENDS FOR REAL warning in their own descriptions and two more warn that they may cause one. Create a second credential from the Test environment key and attach it to the workflows under construction. Then check the other half of the problem: Courier's environments documentation notes that 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 email address or mobile number will still produce a real message even on a Test key. Use contact details you control.
The send node succeeded but nobody received anything
A successful send is an HTTP 202 with a request id, which Courier documents as accepted rather than delivered, so the send node succeeding proves only that Courier took the request. Look the message up with Courier: Get Message using the request id, or find it with Courier: List Messages filtered by recipient. Three statuses explain most of these. UNROUTABLE means no channel could be resolved for that recipient, and Courier: List Providers is the node that explains it, because a channel with no configured provider behind it has nowhere to route to. UNDELIVERABLE means a provider rejected the address, with a reason such as BOUNCED or UNSUBSCRIBED alongside it. UNMAPPED means the template id was not found, which on a Test key is frequently the isolation catching you out rather than a typo, since a template published in Production does not exist in Test. Courier's own documentation also notes that templates default to draft and that sending with a template id which has never been published returns an error.
Template ids, topic ids or brand ids stopped resolving after switching credentials
This is environment isolation working as documented rather than a fault. Courier states that the Test and Production environments are fully isolated and that templates, brands, tags, subscription topics, provider integrations, API keys and log data belong to one environment only, with assets moving between them through its migrate assets feature. So promoting a workflow from a Test credential to a Production one usually means updating the ids the nodes reference as well as the credential. The pickers are the fastest way to do it: re-open the template, topic and brand fields on each node with the new credential attached and choose from the values that environment actually has. Courier: List Preference Sections and Courier: List Notification Templates are worth running once after the swap to see the real catalog.
Courier: Get Template Metrics returns a 402
That is a plan boundary rather than a broken request, and it is the one place in this integration where a plan changes what an endpoint does rather than what it costs. Courier answers HTTP 402 payment required when the requested date range exceeds the plan's maximum lookback, which it documents as 30 days on the free Developer plan and 90 days on Business. The trap is that retry and chunking logic normally treats anything outside the 4xx validation range as a transport failure and retries it unchanged, so the workflow loops rather than asking for less. Shorten the range to fit the plan, or switch to a coarser granularity if the goal was a longer view, remembering that the endpoint's own span limits are separate and depend on granularity, with HOUR capped at 7 days and DAY at 90. Two other reasons this endpoint can look broken while working: it is available in the United States region only, and an unknown template id returns an all-empty series rather than a 404.
A pagination loop never finishes, or returns the same page forever
Courier's cursor pagination comes in three different shapes and a loop written for one hangs on another. Most endpoints answer with a paging object carrying more and cursor, and rows under either results or items depending on the endpoint. Journey and automation runs instead return a flat next_cursor with rows under runs and no more flag at all, so a loop testing paging.more against those never terminates on the first page. Tenants and tenant memberships return a top-level cursor with has_more and rows under items. Every list node names its own shape in its description, so read the node rather than assuming the connector is uniform. One related detail on the two run listers: the limit parameter accepts 1 to 50 and Courier clamps rather than refusing, so a request for 500 quietly returns 50, and a loop that decides it has reached the end by comparing the returned row count against the number it asked for will stop early.
A preference write re-subscribed people who had opted out
Almost always the replace variant was used where the update variant was wanted. Courier: Replace User Preferences in Bulk resets every topic absent from the body to its default, and an empty topics array wipes every override the user has, which re-subscribes anybody whose topics default to opted in. Its response even lists what it removed. Courier: Update User Preferences in Bulk leaves any topic you do not mention exactly as it was, and is what a preference centre should post. The same distinction runs through the connector: Courier: Create or Merge Profile leaves omitted keys alone while Courier: Replace Profile removes them. Where only one topic is involved, Courier: Set User Topic Preference is narrower than either and is the node behind an unsubscribe link. Be careful with Courier: Delete User Topic Preference too, since removing an override resets the person to the effective default, which for an opted-in default means the unsubscribe is undone rather than confirmed.
Everybody in a tenant lost their notification settings after a tenant update
Courier: Create or Replace Tenant is a PUT and it replaces the record rather than patching it, so sending a name without default_preferences clears them for the whole tenant, and the next send to those members routes by workspace defaults instead. There is no in-band signal that anything happened to anyone. Read the tenant first with Courier: Get Tenant, merge your change into what came back, then write the complete object. Where only one topic needs changing, use Courier: Set Tenant Default Preference instead, which is scoped to that topic, and remember it still applies immediately to every member who has not set a personal override. Courier: List Tenant Users is the node for sizing that population before either write.
Requests start failing with a 429
Courier documents per minute limits on specific management endpoints rather than one 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, so a workflow that loops subscription writes one recipient at a time is the usual cause. Prefer the batch shapes: Courier: Add List Subscribers takes many recipients in one additive call, and Courier: Subscribe User to Lists puts one person on several lists at once. For a large send, the bulk flow enqueues the whole batch server side rather than issuing a request per recipient. The template metrics endpoint carries its own per second limit that varies by plan and is worth pacing separately from everything else.
The node I need is not in the palette
Check the list of exclusions above first, because most gaps are deliberate: template and journey authoring, Elemental content and locale overrides, tenant templates, translations, brand and routing strategy documents, broadcast creation, provider configuration, and three destructive operations whose fallout is invisible from the call site. Anything on that list is reachable through Courier: API Request, which takes a method, a path, a query object and a body object and applies the connection's credential. Two things to know before using it. It is flagged destructive and should be treated as a sending node, because nothing stops a path of slash send. And the path must begin with a single slash: a full or protocol-relative URL is refused rather than normalised, so the workspace credential cannot be pointed at another host. Prefer a named node whenever one exists, since the named nodes carry the warnings, the sample outputs and the pickers that a raw request cannot.
A topic picker is empty, or a user id field has no picker at all
Two different situations. An empty topic picker usually means the environment genuinely has no preference sections yet, so run Courier: List Preference Sections on its own to confirm: it returns sections with their topics embedded, and it is the source behind every topic id field here, so an empty response means the catalog is empty rather than the picker being broken. A user id field, by contrast, is free text by design and always will be until Courier changes its API, because Courier ships no endpoint that lists users. A Courier user id is minted by your own system and Courier stores profiles keyed by it, so there is nothing to enumerate. The same applies to message ids, bulk job ids, digest schedule ids and event ids, which are almost always templated from the upstream node that produced them rather than chosen from a list.

Courier 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