// customize
const inkeepSettings = {
  baseSettings: {
    apiKey: "88b123179062d30ee3fe5a5161fd01aecaffe0426ef95f4a", // required
    integrationId: "cm2uo47kh00d5xtuaeqkur3u1", // required
    organizationId: "org_mJdpWbLsGPeOwwPd", // required
    primaryBrandColor: "#3E2A49", // required -- your brand color, the color scheme is derived from this
    organizationDisplayName: "Courier",
    theme: {
      tokens: {
        colors: {
          "gray.600": "#6b7278",
        },
      },
    },
    // ...optional settings
  },
  aiChatSettings: {
    chatSubjectName: "Courier",
    botAvatarSrcUrl:
      "https://framerusercontent.com/images/UaLJKrAmvdMARtdLOIVEDfj5vuQ.svg",
    getHelpCallToActions: [
      {
        name: "GitHub",
        url: "https://github.com/trycourier",
        icon: { builtIn: "FaGithub" },
      },
      {
        name: "Discord",
        url: "https://discord.gg/courier",
        icon: { builtIn: "FaDiscord" },
      },
    ],
    quickQuestions: [
      "How to create and send an email notification?",
      "How to setup a template approval workflow?",
      "Inserting data with variables?",
      "Set up a webhook destination?",
    ],
  },
  modalSettings: {
    // isShortcutKeyEnabled: false, // disable default cmd+k behavior
    // ...optional settings
  },
};

// The Mintlify search triggers, which we'll reuse to trigger the Inkeep modal
const searchButtonContainerIds = [
  "search-bar-entry",
  "search-bar-entry-mobile",
];

// Clone and replace, needed to remove existing event listeners
const clonedSearchButtonContainers = searchButtonContainerIds.map((id) => {
  const originalElement = document.getElementById(id);
  const clonedElement = originalElement.cloneNode(true);
  originalElement.parentNode.replaceChild(clonedElement, originalElement);

  return clonedElement;
});

// Load the Inkeep component library
const inkeepScript = document.createElement("script");
inkeepScript.type = "module";
inkeepScript.src = "https://unpkg.com/@inkeep/uikit-js@0.3.18/dist/embed.js";
document.body.appendChild(inkeepScript);

// Once the Inkeep library is loaded, instantiate the UI components
inkeepScript.addEventListener("load", function () {
  // Customization settings

  // for syncing with dark mode
  const colorModeSettings = {
    observedElement: document.documentElement,
    isDarkModeCallback: (el) => {
      return el.classList.contains("dark");
    },
    colorModeAttribute: "class",
  };

  // Instantiate the 'Ask AI' pill chat button. Optional.
  Inkeep().embed({
    componentType: "ChatButton",
    colorModeSync: colorModeSettings,
    properties: inkeepSettings,
  });

  // Instantiate the search bar modal
  const inkeepSearchModal = Inkeep({
    ...inkeepSettings.baseSettings,
  }).embed({
    componentType: "CustomTrigger",
    colorModeSync: colorModeSettings,
    properties: {
      ...inkeepSettings,
      isOpen: false,
      onClose: () => {
        inkeepSearchModal.render({
          isOpen: false,
        });
      },
    },
  });

  // When the Mintlify search bar elements are clicked, open the Inkeep search modal
  clonedSearchButtonContainers.forEach((trigger) => {
    trigger.addEventListener("click", function () {
      inkeepSearchModal.render({
        isOpen: true,
      });
    });
  });

  // Open the Inkeep Modal with cmd+k
  window.addEventListener(
    "keydown",
    (event) => {
      if (
        (event.metaKey || event.ctrlKey) &&
        (event.key === "k" || event.key === "K")
      ) {
        event.stopPropagation();
        inkeepSearchModal.render({ isOpen: true });
        return false;
      }
    },
    true
  );
});


Courier

Integrations

API Reference

SDK Libraries

Tutorials

Help

Sign Up

Request demo

Login

Invoke an ad hoc automation run. This endpoint accepts a JSON payload with a series of automation steps. For information about what steps are available, checkout the ad hoc automation guide [here](https://www.courier.com/docs/automations/steps/).

Invoke Ad Hoc Automation

Send to users only if they are member of the account

AudienceFilter

A unique identifier associated with an Audience. A message will be sent to each user in the audience.

AudienceRecipient

Automation

AutomationAddToBatchMaxItemsType

Defines what items should be retained and passed along to the next steps when the batch is released

The number of records to keep in batch. Default is 10 and only configurable by requesting from support.
When configurable minimum is 2 and maximum is 100.

Defines the data value data[sort_key] that is used to sort the stored items. Required when type is set to highest or lowest.

Keep N number of notifications based on the type. First/Last N based on notification received.
highest/lowest based on a scoring key providing in the data accessed by sort_key

AutomationAddToBatchRetain

AutomationAddToBatchRetainType

AutomationAddToBatchScope

If using scope=dynamic, provide the key or a reference (e.g., refs.data.batch_key)

Defines the field of the data object the batch is set to when complete. Defaults to `batch`

If specified, the batch will release as soon as this number is reached

Defines the maximum wait time before the batch should be released. Must be less than wait period. Maximum of 60 days. Specified as an [ISO 8601 duration](https://en.wikipedia.org/wiki/ISO_8601#Durations)

Determine the scope of the batching. If user, chosen in this order: recipient, profile.user_id, data.user_id, data.userId.
If dynamic, then specify where the batch_key or a reference to the batch_key

Defines the period of inactivity before the batch is released. Specified as an [ISO 8601 duration](https://en.wikipedia.org/wiki/ISO_8601#Durations)

AutomationAddToBatchStep

The subscription topic that has digests enabled

AutomationAddToDigestStep

AutomationCancelStep

The [ISO 8601 duration](https://en.wikipedia.org/wiki/ISO_8601#Durations) string for how long to delay for

The ISO 8601 timestamp for when the delay should end

AutomationDelayStep

AutomationFetchDataStep

AutomationFetchDataWebhook

AutomationFetchDataWebhookMethod

AutomationInvokeStep

AutomationSendListStep

AutomationSendStep

AutomationStep

AutomationStepOption

The node to go to if the request is throttled

AutomationThrottleOnThrottle

AutomationThrottleScope

Maximum number of allowed notifications in that timeframe

Defines the throttle period which corresponds to the max_allowed. Specified as an ISO 8601 duration, https://en.wikipedia.org/wiki/ISO_8601#Durations

If using scope=dynamic, provide the reference (e.g., refs.data.throttle_key) to the how the throttle should be identified

AutomationThrottleStep

AutomationUpdateProfileStep

AutomationV2SendStep

"Define run-time configuration for one or more channels. If you don't specify channels, the default configuration for each channel will be used. Valid ChannelId's are: email, sms, push, inbox, direct_message, banner, and webhook."

Context to load with this recipient. Will override any context set on message.context.

An arbitrary object that includes any data you want to pass to the message.
The data will populate the corresponding template or elements variables.

Defines the time to wait before delivering the message. You can specify one of the following options. Duration with the number of milliseconds to delay. Until with an ISO 8601 timestamp that specifies when it should be delivered. Until with an OpenStreetMap opening_hours-like format that specifies the [Delivery Window](https://www.courier.com/docs/platform/sending/failover/#delivery-window) (e.g., 'Mo-Fr 08:00-18:00pm')

"Expiry allows you to set an absolute or relative time in which a message expires.
Note: This is only valid for the Courier Inbox channel as of 12-08-2022."

An object whose keys are valid provider identifiers which map to an object.

Time in ms to attempt the channel before failing over to the next available channel.

BaseMessage

The recipient or a list of recipients of the message

BaseMessageSendTo

Id of the brand that should be used for rendering the message.
If not specified, the brand configured as default brand will be used.

A JavaScript conditional expression to determine if the message should
be sent through the channel. Has access to the data and profile object.
For example, `data.name === profile.name`

A list of providers enabled for this channel. Courier will select
one provider to send through unless routing_method is set to all.

The method for selecting the providers to send the message with.
Single will send to one of the available providers for this channel,
all will send the message through all channels. Defaults to `single`.

Channel

ChannelClassification

ChannelMetadata

ChannelPreference

ChannelSource

Content

The message property has the following primary top-level properties. They define the destination and content of the message.
Additional advanced configuration fields [are defined below](https://www.courier.com/docs/reference/send/message/#other-message-properties).

Describes the content of the message in a way that will work for email, push,
chat, or any channel. Either this or template must be specified.

ContentMessage

Criteria

The duration of the delay in milliseconds.

An ISO 8601 timestamp that specifies when it should be delivered or an OpenStreetMap opening_hours-like format that specifies the [Delivery Window](https://www.courier.com/docs/platform/sending/failover/#delivery-window) (e.g., 'Mo-Fr 08:00-18:00pm')

Delay

Allows the user to execute an action. Can be a button or a link.

A unique id used to identify the action when it is executed.

The alignment of the action button. Defaults to "center".

The background color of the action button.

The text content of the action shown to the user.

ElementalActionNode

ElementalBaseNode

The channel element allows a notification to be customized based on which channel it is sent through.
For example, you may want to display a detailed message when the notification is sent through email,
and a more concise message in a push notification. Channel elements are only valid as top-level
elements; you cannot nest channel elements. If there is a channel element specified at the top-level
of the document, all sibling elements must be channel elements.
Note: As an alternative, most elements support a `channel` property. Which allows you to selectively
display an individual element on a per channel basis. See the
[control flow docs](https://www.courier.com/docs/platform/content/elemental/control-flow/) for more details.

The channel the contents of this element should be applied to. Can be `email`,
`push`, `direct_message`, `sms` or a provider such as slack

An array of elements to apply to the channel. If `raw` has not been
specified, `elements` is `required`.

Raw data to apply to the channel. If `elements` has not been
specified, `raw` is `required`.

ElementalChannelNode

ElementalContent

Syntatic Sugar to provide a fast shorthand for Courier Elemental Blocks.

The text content displayed in the notification.

The title to be displayed by supported channels i.e. push, email (as subject)

ElementalContentSugar

Renders a dividing line between elements.

The CSS color to render the line with. For example, `#fff`

ElementalDividerNode

Allows you to group elements together. This can be useful when used in combination with "if" or "loop". See [control flow docs](https://www.courier.com/docs/platform/content/elemental/control-flow/) for more details.

ElementalGroupNode

Used to embed an image into the notification.

A URL to link to when the image is clicked.

CSS width properties to apply to the image. For example, 50px

ElementalImageNode

The meta element contains information describing the notification that may
be used by a particular channel or provider. One important field is the title
field which will be used as the title for channels that support it.

The title to be displayed by supported channels. For example, the email subject.

ElementalMetaNode

ElementalNode

CSS border color property. For example, `#fff`

ElementalQuoteNode

Represents a body of text to be rendered inside of the notification.

Specifies the color of text. Can be any valid css color value

The text content displayed in the notification. Either this
field must be specified, or the elements field

Allows the text to be rendered as a heading level.

ElementalTextNode

ExpiresInType

An epoch timestamp or ISO8601 timestamp with timezone `(YYYY-MM-DDThh:mm:ss.sTZD)` that describes the time in which a message expires.

A duration in the form of milliseconds or an ISO8601 Duration format (i.e. P1DT4H).

Expiry

IActionButtonStyle

IAlignment

IPreferences

IProfilePreferences

ListFilter

ListPatternRecipient

ListPatternRecipientType

ListRecipient

ListRecipientType

MergeAlgorithm

Describes the content of the message in a way that will work for email, push, chat, or any channel.

A template for a type of message that can be sent more than once. For example, you might create an "Appointment Reminder" Notification or “Reset Password” Notifications.

Message

MessageChannels

An id of a tenant, see [tenants api docs](https://www.courier.com/docs/reference/tenants/).
Will load brand, default preferences and any other base context data associated with this tenant.

MessageContext

MessageData

An arbitrary string to tracks the event that generated this request (e.g. 'signup').

A unique ID used to correlate this request to processing on your servers. Note: Courier does not verify the uniqueness of this ID.

Identify the campaign that refers traffic to a specific website, and attributes the browser's website session.

MessageMetadata

The ID of the subscription topic you want to apply to the message. If this is a templated message, it will override the subscription topic if already associated

MessagePreferences

MessageProviders

A JavaScript conditional expression to determine if the message should be sent
through the channel. Has access to the data and profile object. For example,
`data.name === profile.name`

MessageProvidersType

MessageRecipient

MsTeams

MsTeamsBaseProperties

MsTeamsRecipient

Pagerduty

PagerdutyRecipient

Preference

PreferenceStatus

Profile

Recipient

RecipientData

Allows you to customize which channel(s) Courier will potentially deliver the message.
If no routing key is specified, Courier will use the default routing configuration or
routing defined by the template.

A list of channels or providers to send the message through. Can also recursively define
sub-routing methods, which can be useful for defining advanced push notification
delivery strategies.

Routing

RoutingChannel

RoutingMethod

RoutingStrategyChannel

RoutingStrategyProvider

Rule

SendToMsTeamsChannelId

SendToMsTeamsChannelName

SendToMsTeamsConversationId

SendToMsTeamsEmail

SendToMsTeamsUserId

SendToSlackChannel

SendToSlackEmail

SendToSlackUserId

Slack

SlackBaseProperties

SlackRecipient

The id of the notification template to be rendered and sent to the recipient(s).
This field or the content field must be supplied.

TemplateMessage

TextAlign

TextStyle

Timeout

Timeouts

Context information such as tenant_id to send the notification with.

An id of a tenant, [see tenants api docs](https://www.courier.com/docs/reference/tenants).
Will load brand, default preferences and any other base context data associated with this tenant.

UserRecipient

UserRecipientType

WebhookAuthMode

The authentication mode to use. Defaults to 'none' if not specified.

WebhookAuthentication

WebhookMethod

Authentication configuration for the webhook request.

Custom headers to include in the webhook request.

The HTTP method to use for the webhook request. Defaults to POST if not specified.

Specifies what profile information is included in the request payload. Defaults to 'limited' if not specified.

Getting Started

Send

Audiences

Audit Events

AuthTokens

Automations

Brands

Bulk

Inbound

Lists

Messages

Notifications

Profiles

Tenants

Translations

User Preferences

User Tenants

User Tokens

Invoke Ad Hoc Automation

Authorizations

Body

Response