// 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://uikit.inkeep.com/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
  );
});


The Courier REST API provides several endpoints that allow your application to send messages, request details about an individual message, and manage profile and preference information for each recipient in your audience.

Introduction

Courier

Find all the tutorials and resources you need to build product notifications with Courier.

Home

Welcome to the Courier Documentation

Courier lets you design your notifications once and deliver them to any channel-push notifications, direct messages, SMS, and email-with a single [Courier API](../reference/intro) rather than having to integrate each provider API separately.

What is Courier?

Courier terms and concepts you will commonly see when you use Courier's notification platform.

Courier Concepts

Quickstart

Courier Quickstart Guide

Courier Platform Overview

Overview

Courier Users

Courier uses the term `user` to describe the recipient of a notification.

Users

The Courier CLI is a developer tool to help you build, test, and manage your integration with Courier directly from the command line.

Courier CLI

A Postman collection for the Courier API.

Courier and Postman

Find the answers to your questions or explore helpful resources.

Courier Help Center

Tutorials

An overview of Courier automation features, its core concepts and example use cases.

How to Understand Automation Concepts

A walkthrough on how to send Courier Automations through an ad-hoc API request, or template.

How To Send Automations

Learn how to send browser and mobile push notifications using Segment and Courier.

How To Send Notifications With Segment

Learn how to leverage different Courier mechanisms to send digests.

How To Send Digests

Design Your First Notification Template

Learn how to use Courier's AI content generator to build and iterate on notification content rapidly.

How to Use AI to Build Notifications

Learn how to give your email notifications a consistent look and feel for you and your customers.

How to Use Brands to Customize Email Notifications

The Courier Notification Designer allows you to preview branding, content, test variables or Handlebars code in each channel and send test emails.

How to Use Test Events

Learn how to create and Send branded notifications for consistent look and feel across your communications.

How to Create and Send Your First Brand

Inbox is an in-app notification center you can use to notify your users. Inbox allows you to build high quality, flexible notification feeds very quickly.

How to Implement Courier Inbox

Learn how to incrementally build a notification that goes out to a very large number of users and then execute the send with a single API call.

How To Send Bulk Notifications

Learn how to structure the List IDs you create via the Lists API according to the pattern guidelines that enable wildcard sending.

How To Create And Send To A List Or List Pattern

Learn how to configure a user's notification preferences through the preferences API endpoint.

How To Configure User Preferences

This guide will walk you through triggering a product notification using the Courier Send API or a Segment integration through an automation.

How To Send A Product Notification

How to Send a One-Time Notification

This how to guide walks you through sending a notification with Courier.

How To Send Your First Message

When formatting emails in HTML, it's important to consider the compatibility across different email clients, as some may not support certain CSS styles or HTML tags.

How To Safely Format Emails

This how to guide walks you through configuring multi-channel routing for your product notifications with Courier.

How To Configure Multi-Channel Routing

Courier integrates with many different external notification providers for email, push, SMS, and more that fit your business use case. Courier offers an extensive list covering many different delivery channels, and we're continously updating our existing integrations and adding new ones.

External Notification Providers

The Courier REST API supports both token and basic authorization.

Authentication

The API supports [idempotency](https://en.wikipedia.org/wiki/Idempotence) for safely retrying requests without accidentally performing the same operation twice.

Idempotent Requests

A **rate limiter** limits the number of requests received by the API within any given second. For most endpoints, Courier does not rate limit.

Rate Limiting

Working with Courier is easier once you understand some of the terminology common to our service. You will be working with **Notifications**, **Integrations**, and **Channel Rules**.

Courier Vocabulary

The send API lets you send a message to one or more recipients with a single call. Messages are sent asynchronously, so when you call the send API, the response will contain a request ID that you can use to check the status of your message later.

Use the send API to send a message to one or more recipients.

Send a message

The Audiences API helps you build collections of users based on rules. These rules can be as simple as "users in California," but can also be extended to more complex sets of operations. This is different from [lists](/docs/reference/lists/) in which the members of the collection are statically defined by subscribe and unsubscribe actions.

Audiences

Audience operators are used to match a user's profile against a set of criteria.

Audience Operators

Once you define an audience and confirm the rules are including the correct set of users, you can use Send endpoint to send to the audience like this:

Usage

Get an audience

Update an audience

Delete an audience

List audience members

Get the audiences associated with the authorization token.

List all audiences

Audit Events

Get all audit events

Get an audit event

The Auth API provides endpoints for granting access tokens for granular endpoint permissions.

Create an auth token

The Automations API provides endpoints to:

Automations API

Invoke an automation run from an automation template.

Invoke an Automation

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

The Brands API lets you read, write and create brands programmatically. Brands are themed email templates with custom headers and footers that can be applied to any notifications. Updates to a brand are immediately applied any notifications using that brand automatically.

Brands API

Create a new brand

Get a brand

List brands

Delete a brand

Replace an existing brand with the supplied values.

Replace a brand

Bulk processing allows you to send message definitions to large numbers of users in a single API invocation.

Create a bulk job

Add users

Run a job

Get a Job

Get users

Courier Track Event

The Lists API helps you build lists of [users](/docs/platform/users/), which is useful for when you want to easily [send messages to a group](/docs/platform/users/#lists-and-audiences). List are defined by subscribing or unsubscribing users to them. This is different from [audiences](/docs/reference/audiences/intro) in which the members of the audience are defined dynamically based on user attributes.

Lists

Returns all of the lists, with the ability to filter based on a pattern.

Get all lists

Returns a list based on the list ID provided.

Get a list

Create or replace an existing list with the supplied values.

Update a list

Delete a list

Restore a list

Get the subscriptions for a list

Subscribes the users to the list, overwriting existing subscriptions. If the list does not exist, it will be automatically created.

Subscribe users to a list

Subscribes additional users to the list, without modifying existing subscriptions. If the list does not exist, it will be automatically created.

Add subscribers to a list

Subscribe a user to an existing list (note: if the List does not exist, it will be automatically created).

Subscribe a single user to a list

Delete a subscription to a list by list ID and user ID.

Unsubscribe a user from a list

The Messages API provides access to message data and the ability to cancel the sending of a message.

Messages

Fetch the statuses of messages you've previously sent.

List messages

Fetch the status of a message you've previously sent.

Get message

Cancel a message that is currently in the process of being delivered. A well-formatted API call to the cancel message API will return either `200` status code for a successful cancellation or `409` status code for an unsuccessful cancellation. Both cases will include the actual message record in the response body (see details below).

Cancel message

Fetch the array of events of a message you've previously sent.

Get message history

Get message content

Archive message

The Profiles API allows you to manage profile information associated with a [user](/docs/platform/users/). The profile object conforms with [OIDC standard claims](https://openid.net/specs/openid-connect-core-1_0.html#StandardClaims).

Profiles API

Get a profile

Merge the supplied values with an existing profile or create a new profile if one doesn't already exist.

Create a profile

Update a profile

When using `PUT`, be sure to include all the key-value pairs required by the recipient's profile.
Any key-value pairs that exist in the profile but fail to be included in the `PUT` request will be
removed from the profile. Remember, a `PUT` update is a full replacement of the data. For partial updates,
use the [Patch](https://www.courier.com/docs/reference/profiles/patch/) request.

Replace a profile

Delete a profile

Returns the subscribed lists for a specified user.

Get list subscriptions

Subscribes the given user to one or more lists. If the list does not exist, it will be created.

Subscribe to one or more lists

Removes all list subscriptions for given user.

Delete list subscriptions

The Tenants API is designed to enable multi-tenant notification workflows. This is useful for defining user to tenant level relationships, especially in the context of B2B applications.

Tenants

Create or Replace a Tenant

Get a Tenant

Get a List of Tenants

Delete a Tenant

Get Users in Tenant

Create Tenant Preferences

Remove Tenant Preferences

The Translations API allows you to read/write translations to Courier in the form of .po files ([https://www.gnu.org/software/gettext/manual/html node/PO-Files.html](https://www.gnu.org/software/gettext/manual/html_node/PO-Files.html)).

Translations

Get a translation

Update translations by locale

User Preferences API

Get user's preferences

Fetch user preferences for a specific subscription topic.

Get user subscription topic

Update or Create user preferences for a specific subscription topic.

Update or Create user preferences for a specific subscription topic

Returns a paginated list of user tenant associations.

Get tenants associated with a given user

This endpoint is used to add a user to
multiple tenants in one call.
A custom profile can also be supplied for each tenant.
This profile will be merged with the user's main
profile when sending to the user with that tenant.

Add a User to Multiple Tenants

Removes a user from any tenants they may have been associated with.

Remove User From All Associated Tenants

This endpoint is used to add a single tenant.

A custom profile can also be supplied with the tenant.
This profile will be merged with the user's main profile
when sending to the user with that tenant.

Add a User to a Single Tenant

Remove User from a Tenant

The Token Management API is used to store and track user device tokens. User device tokens are commonly used to send push notifications.

Adds multiple tokens to a user and overwrites matching existing tokens.

Add multiple tokens to user

Adds a single token to a user and overwrites a matching existing token.

Add single token to user

Apply a JSON Patch (RFC 6902) to the specified token.

Update a token

Get single token available for a `:token`

Get single token

Get all tokens

You can access our REST API and integrate Courier into your application using one of our [server SDK](./server-sdks) libraries.

SDK Libraries

Server SDKs

Client SDKs

The Courier React SDK provides access to a set of UI components and hooks that make building rich web applications with Courier easy. 

Getting Started

Send

Audiences

Audit Events

AuthTokens

Automations

Brands

Bulk

Inbound

Lists

Messages

Notifications

Profiles

Tenants

Translations

User Preferences

User Tenants

User Tokens

Introduction