Tutorial

Product News

Courier Updates

User Experience

Product Management

Integrations

Engineering

Live Streaming

Notifications Landscape

Courier

Courier Live Thumbnail

The Courier Team

Transactional emails are automated emails triggered by a user (or group of users) taking action on your web or mobile application. Some examples include [password reset emails](https://www.courier.com/blog/how-to-send-password-resets-via-sms-and-email-using-node-js-and-next-js/), confirmation emails for purchases or reservations, welcome and onboarding emails, and shipping notifications.

Often transactional emails require more advanced logic like honoring user notification preferences, [batching](https://www.courier.com/docs/automations/batching/)/[digesting](https://www.courier.com/docs/automations/digest/) frequent messages, [internationalization](https://www.courier.com/docs/courier-designer/notification-designer/internationalizing-notifications/), provider [failover](https://www.courier.com/docs/guides/business/failover/), and routing across other channels like Push, Slack, and SMS. That’s why it’s important to pair your email provider with Courier’s notification infrastructure. This way it’s easy to build in the full set of features required for production and to expand, monitor, and scale your transactional email over time.

Today we’ll look at a simple use case for building transactional notifications with Twilio SendGrid via Courier’s API. The examples in this tutorial use [Courier's Node.js](https://github.com/trycourier/courier-node) SDK; however, Courier also provides SDKs for other [languages](https://www.courier.com/integrations/#libraries) including Python, Java, PHP and Ruby.

## How to send transactional emails with Twilio SendGrid using Courier

### Step 1. Integrate SendGrid with Courier

Log in to your SendGrid account and go to [Settings → API Keys](https://app.sendgrid.com/settings/api_keys). Click __Create API Key__ and then give your key a name. Now, choose __Restricted Access__ and toggle the __Mail Send__ setting, and then click __Create & View__. Your API key will now be displayed. Copy it and put it somewhere safe as it cannot be shown to you again.

![send-transactional-emails-with-sendgrid-9](//images.ctfassets.net/z7iqk1q8njt4/60C6t8aTP83U54V6pHul83/563752b23ef6bccd169ce0c8ed2b3436/image9.gif)

Next, log into [Courier](https://app.courier.com/) and go to the [Channels](https://app.courier.com/channels) page. To send via SendGrid, look for __SendGrid__ in the Provider Catalogue under __Email__ and click on it. Enter your SendGrid API key, along with the email address that you want your SendGrid messages to be sent from. This must be an email account that you have access to, as you'll be required to click a link in an email to verify that it is your account.

There is also the option to create a test configuration, which means there will be a test API key that your test systems can use.

![send-transactional-emails-with-sendgrid-5](//images.ctfassets.net/z7iqk1q8njt4/11d1f430Hz5DINhAQRmRvZ/c520cf877339324a745d3bfea88f0e10/image5.gif)

After you’ve filled out this form, click __Install Provider__.

### Step 2. Design your transactional email template

In the Courier app, navigate to [Designer](https://app.courier.com/designer) and click __Create Template__. Choose a name for your template.

![send-transactional-emails-with-sendgrid-10](//images.ctfassets.net/z7iqk1q8njt4/29dGXD0eggZheZocpAQ7ee/7562c9a63c67f5b03f8f666b1f2d1699/image10-opt.jpg)

Next, select SendGrid as the provider for your message. Select the __email__ notification channel, and choose __SendGrid__ as the provider. This will add an email channel to your list of channels on the left-hand side. Click the email channel to add the content to your email template.

![send-transactional-emails-with-sendgrid-2](//images.ctfassets.net/z7iqk1q8njt4/3tXY7wHzKSNZDjTqUg8sbe/820884bd718014e44baeb9fb70147134/image2.png)

To write the content for your SendGrid notification template, use the drag-and-drop, no-code editor. To add variables to your notification, add them inside curly braces, which Courier highlights in green.

![send-transactional-emails-with-sendgrid-3](//images.ctfassets.net/z7iqk1q8njt4/2dMqeV5FE1I9tcvhui6PvS/8fc2e4b681f78c57e90cbd6d9cbbef97/image3.png)

To edit the branding of your emails, click the three dots at the top right of the editor and select __View brand__. Here, you can make branding changes such as adding a company logo or changing colors and fonts, if you wish.

Once you have designed your email, finalize it by clicking the __Publish Changes__ button at the top right of the page.

### Step 3. Test and verify your email before sending

To verify your email template design, select the __Preview__ tab and click __Create Test Event__. You'll now see some JSON, with the variables from your template listed in the __data__ section. Try changing their values, and then click __Create Test Event__.

![send-transactional-emails-with-sendgrid-6](//images.ctfassets.net/z7iqk1q8njt4/1hALvWWspNiZDvxXGazufz/261afbe66eab55f43406194d553f1778/image6.png)

You'll now see an example of how your email will appear, complete with your chosen variable values:

![send-transactional-emails-with-sendgrid-4](//images.ctfassets.net/z7iqk1q8njt4/5RZRHJ1KPGQdryiAVGEjpw/79cf64e0e0e354ddad9bdcf07e8a1342/image4.png)

Before sending transactional emails to real users, you should also test them to ensure they work correctly. Click the __Send__ tab and then click __Send Test__. You should now receive an email sent to the email address inside the __to__ section of the JSON below:

![send-transactional-emails-with-sendgrid-8](//images.ctfassets.net/z7iqk1q8njt4/4zjC4D4wLJr78luzLLazKf/89c8b80f2ec89238a8c842971dc8fcee/image8.png)

Note that this page also contains your Courier Auth Token. Copy this now, for use in your application code later.

Once you’ve received the test email and verified that everything in it is correct, you are now ready to use the provided code snippet in your back-end application to send your notification emails.

### Step 4. Sending the transactional email from your application

In this tutorial, we will use [Node.js](https://www.courier.com/docs/guides/getting-started/nodejs/), for which [Courier provides an SDK](https://github.com/trycourier/courier-node). To get the Node.js code snippet that you need, select __Node.js__ from the drop-down box at the top of the snippet on the __Send Test__ page in Courier.

First, install the [@trycourier/courier](https://www.npmjs.com/package/@trycourier/courier) package via npm:

```javascript
npm install @trycourier/courier
```

---

Now, copy the Node.js snippet into your Node project, and fill in the variables to use real values (such as __John Doe__).

```javascript
const { CourierClient } = require("@trycourier/courier");
const courier = CourierClient({ authorizationToken: "<AUTH_TOKEN>" });

const { requestId } = courier.send({
  message: {
	to:  {
              email: "<EMAIL_ADDRESS>", 
  	},
	template: "<NOTIFICATION_ID>",
	data: {
          userName: "John Doe",
          passwordResetLink: "https://your-domain.com/passwordreset",
          companyName: "Acme",  
      },
  },
});
```

Note that the __data__ section is the part where you can add all the variables you want to reference inside your email template.

Replace `<AUTHTOKEN>` with your recently copied Courier Auth Token, `<EMAIL_ADDRESS>` with your own email address, and replace `<NOTIFICATION_ID>` with the ID of your template, which can be found inside your notification template in Courier by going to the notification template settings. Once you have run the code and verified that the email is sent correctly, you will want to replace your email address with a variable containing your user’s email address.

![send-transactional-emails-with-sendgrid-1](//images.ctfassets.net/z7iqk1q8njt4/5nMi01fRHrNDjYWiE05KAf/3d22b0bc7e5c2cf033ee53d8098a75ef/image1.gif)

## Debugging any issues with your transactional emails

To debug issues such as your transactional emails failing to send, [view your message logs](https://www.courier.com/docs/notification-data/message-logs/) to troubleshoot. You can view the status of each message, including whether it was sent, is stuck in a queue, was not sent due to rate limits being reached, or was considered undeliverable.

![send-transactional-emails-with-sendgrid-7](//images.ctfassets.net/z7iqk1q8njt4/1evpqObQd5tIfFtRchrfJf/2da49e5d5324a8f97db053d6fe88fe94/image7.gif)

You can filter your logs by provider, so you can easily learn if there is a specific issue with your SendGrid messages in particular. Or you can filter by notification template, email address, or trace ID. If you need more help with mail sending issues, [read our documentation](https://www.courier.com/docs/guides/providers/email/sendgrid/) or [contact Courier support](https://discord.com/invite/courier) for assistance.

## Conclusion

Using SendGrid and Courier to send transactional emails with Node.js is a straightforward process that only needs a few lines of code to implement. By following the steps outlined in this tutorial, you can easily send personalized, targeted messages to your customers. We hope this tutorial will be helpful in getting you started with sending transactional emails using Courier. If you have any questions or feedback, please [join our community](https://discord.com/invite/courier)!

Provider catalog_sendgrid

Tutorial for building transactional email notifications triggered by a user action; using Sendgrid with Courier’s notification infrastructure

How to Send Transactional Emails Using SendGrid with Notification Infrastructure

Provider selection_sendgrid

carter-rabasa-twilio-beard-cropped

Carter Rabasa

Courier makes it easy to send SMS, email, push and in-app notifications with a single API call. We have a REST API, client SDKs and Docs that you'll love 💜

Create Your Free Developer Account

Next.js + Courier

Tutorial for building password reset into a Node.js application using Next.js, Vercel KV and Courier.

How to Send Password Resets via SMS and email using Node.js and Next.js

Next.js password reset blog post code

shreya-headshot

Shreya Gupta

# Introduction

All apps need a solid, automated notifications system. Whether it’s reminders, updates, or alerts, some notifications can be urgent and time-sensitive, in which case SMS is the most effective communication channel.

Let’s take a moment to talk about what that means for you as a developer. You need to:
* store data on how each individual user is interacting with your app,
* design personalized messages that inform your users based on different activities,
* respect your user’s communication preferences to avoid notification fatigue,
* and view logs in a centralized location for efficient debugging.

Realistically, building this feature from scratch can be time-consuming and complicated. You risk wasting time on simple tasks like integrating with SMS providers, managing message delivery, and scaling your system to handle increased message volume.

To simplify this process, we will use Courier, which provides a layer of abstraction over multiple SMS providers, making integration easier. It includes:
* CDP integrations to send automated messages based on user activity
* message delivery tracking and retry mechanisms, which can help ensure reliable message delivery
* scalable architecture, which can handle increased message volume as your application grows.

This tutorial will cover everything you need to know to set up an effective and efficient automated SMS notification system using Courier. Let’s begin.

# Send with SMS

The following is a simple API call that sends SMS messages with Courier, adapted from the [Node.js quick start](https://www.courier.com/docs/guides/getting-started/nodejs/): 

```javascript
const { CourierClient } = require("@trycourier/courier");

const courier = CourierClient({ authorizationToken: "<auth_token>" });

async function sendSMS() {
    const { requestId } = await courier.send({
        message: {
            to: {
                phone_number: "123-456-7890",
            },
            content: {
                title: "Welcome!",
                body: "Thanks for signing up, {{name}}",
            },
            data: {
                name: "Peter Parker",
            },
            routing: {
                method: "single",
                channels: ["sms"],
            },
            },
    });
}

sendSMS();
```

## Integrate SMS API

You can use Twilio or [any of the following providers](https://www.courier.com/docs/guides/providers/sms/) based on your preference.

** Step 1: [Sign up for Twilio](https://www.twilio.com/try-twilio)**

** Step 2: Set up your preferred SMS API in [channels](https://app.courier.com/channels)**

Each Courier Integration needs specific information based on the Integration provider's requirements (check the **Provider Documentation** section on the left sidebar for each Integration's needs).

For Twilio, you will need to provide an **[Account SID](https://console.twilio.com/)**, an **[Auth Token](https://console.twilio.com/)**, and a **[Messaging Service SID](https://www.twilio.com/docs/messaging/guides/best-practices-at-scale)**, which you will get directly from Twilio. If you don’t have a Messaging Service SID from Twilio, you can add a **From Number** instead.

![Add Twilio channel](//images.ctfassets.net/z7iqk1q8njt4/y0Djn4VAYJTNo2WFFN0Wi/dc791a6c406960a0c416bf1b03d17899/image-1.png)

After you sign in to Twilio, click the house icon on the sidebar to go to the **Dashboard**. On this page, you'll see a section called **Project Info**, which shows your **Account SID** and **Auth Token**. Copy these and paste them into the matching fields on Courier's Twilio Integration page.

![](./images/image-2.png)
![Twilio account info](//images.ctfassets.net/z7iqk1q8njt4/2IDv94v66vmxo2AxU1ocmT/3f6083af3496e761c77c9d1f18ad35e0/image-2.png)

You can find more information on how to get a phone number from Twilio and how to set up a Messaging Service SID in our [Twilio documentation](https://www.courier.com/docs/guides/providers/sms/twilio/).

## Create Your Notification(s)

**Step 1: Create a new template**

Go to the Courier Designer and click on the **Create Notification** button to create a new notification template. You will need to give your notification a name (otherwise it will default to “Untitled Notification”. You can choose to use AI to generate content based on the name you chose.

Leave the Subscription Topic blank for now.

**Step 2: Select your preferred channel and integration**

In this case, you will use the SMS channel and Twilio integration.

**Step 3: Customize your message and publish changes when complete**

** Step 4: Add links to the Preference Center**

You’ll set up your Preference Center later in this tutorial, but you can add links to the Preference Center here by including `({$.urls.preferences})` in the message or hyperlinking text with `{$.urls.preferences}`. [Learn more.](https://www.courier.com/docs/courier-preferences/preference-center/hosted-page/#adding-preferences-link-to-notification-text)

**Optional Step 4: Test your event**

To confirm that your message is appearing the way you’d expect it to, go to the Preview tab and create a new test event. Replace the value of `phone_number` in the JSON with a number you would like to receive the test SMS at. Click create and proceed to the Send tab. Click Send Test to receive the test message. Click on the Design tab to revise the message until you are satisfied with the way it looks.

[Learn more about designing templates.](https://www.courier.com/docs/guides/tutorials/how-to-design-a-notification-template/)

**Step 5: Repeat this process to create all notifications you need to send via SMS**

## Create an Automation

**Step 1: [Create a new Automation](https://app.courier.com/automations)**

**Step 2: Drag and drop your preferred trigger**

If you have integrated a CDP in Courier and want to send notifications based on events being tracked within your application, you can choose any of them as the trigger (Segment or Rudderstack).

This will require you to have the integration setup within the CDPs:
* [Send Segment events to Courier](https://segment.com/docs/connections/destinations/catalog/courier/)
* [Send Rudderstack events to Courier] (https://www.rudderstack.com/docs/destinations/streaming-destinations/courier/)

**Step 3: Drag and drop a Send step**

Connect the notification template based on which message you want to send with this trigger.

Edit the recipient information:
* add a `phone_number` field to send to a specific number,
* add a `user_id` to send to a specific contact within your [Courier Users database](https://app.courier.com/users0,
* or add a `list_id` to send to a list of users (another way to do this is to use the Send to List step)

**Step 4: Publish the Automation template**

[Learn more about designing Automation templates](https://www.courier.com/docs/automations/designer/)

## Set up user preferences

To allow your users to decide how they receive messages, you can use Subscription Topics to categorize your notifications and give users the ability to opt in/out of these Topics.

**Step 1: Create Subscription Topics**

Head over to the [Preferences Designer](https://app.courier.com/designer/preferences) and add your Topics. Some examples are “Marketing Messages,” “Billing Alerts,” and “Critical Messages.” You can edit the Default State of each Topic to decide whether users can opt in/out or if they are required to receive these notifications.

**Step 2: Link the Notification Templates**

Edit your Topics to link the Templates you created earlier.

**Optional Step 3: Enable Channel Delivery Customization**

You can also edit the Section settings (a Section groups multiple topics together) and enable Channel Delivery Customization so users can decide which channel they receive messages on. This means that if a user opts out of “SMS” notifications for a Section, they will not receive any SMS notifications within the Topics of that Section.

Learn more about the [Preferences Designer](https://www.courier.com/docs/courier-preferences/preference-center/designer/).

# Best Practices for SMS Notifications

The ease and convenience of SMS have made it an effective and popular method for delivering messages to customers, employees, and stakeholders. However, best practices must be followed to ensure the effectiveness of SMS notifications. Here are some of the best practices for SMS notifications:

## A. Timing and frequency of SMS notifications

SMS notifications require precise timing and frequency to be effective. The notifications should be sent at the optimal time for the recipient to read and respond to the message. For example, a retail store may send SMS notifications to customers with promotions and discounts during the holiday season or a special sale event. Similarly, a healthcare provider may send reminders to patients for upcoming appointments or medication refills. It is also important to avoid overloading the recipient with too many messages. Finding the right balance between frequency and relevance is crucial to ensure that SMS notifications are well-received and effective.

## B. Personalizing the SMS notifications for each recipient

Personalization is a key factor in delivering effective SMS notifications. By personalizing the message with the recipient's name, location, or other relevant information, it becomes more engaging and meaningful. Personalized SMS notifications can also help to build stronger relationships between the sender and recipient. For example, a fitness center may send SMS notifications to members with personalized workout plans based on their fitness goals and progress. Similarly, a bank may send personalized SMS notifications to customers with account balances and transaction details.

## C. Measuring the success of SMS notifications with analytics

Analytics can provide valuable insights into how the recipient is engaging with the message. For example, open rates, click-through rates, and conversion rates can indicate the effectiveness of the SMS notification. By analyzing these metrics, the sender can identify areas for improvement and make data-driven decisions. Analytics can also help to refine the timing and frequency of SMS notifications.

## D. Improving the SMS notification strategy based on recipient engagement

Finally, we can continuously improve the SMS notification strategy based on recipient engagement. By soliciting feedback from recipients, the sender can better understand their preferences and needs. For example, a survey or feedback form can be included in the SMS notification to gather feedback from the recipient. Based on this feedback, the sender can adjust the timing, frequency, and content of the SMS notifications to meet the recipient's needs better.

# Conclusion

Now you have a completely automated SMS notification system that respects your user’s preferences. Creating an automated SMS notification system with Courier and Twilio is a powerful way to enhance customer communication. Courier's advanced features, like multi-channel support, pre-built templates, and detailed analytics, make it a great tool for managing all your notifications in one place. Twilio's SMS API is easy to use and provides a wide range of features, like two-factor authentication and automated responses, to help you create an efficient and secure notification system. Combining these two powerful tools allows you to create a notification system that meets your business needs and helps you stay connected with your customers.


Courier is a notification service that centralizes all of your templates and messaging channels in one place which increases visibility and reduces engineering time. 

Start Routing Notifications Today!

automate-sms-header

Tutorial on building automation SMS notification system with Twilio with user preference management.

automate-sms-thumbnail

How to Create an Automated SMS Notification System

There are ways to integrate cross-channel notifications via individual APIs, but we’re here to provide you with a quick guide to send across your preferred channels in one single API call. This guide will focus on sending and automating messages via Slack, MS Teams, and any other channel of your choice from your Node.js applications.

You can also [automate Slack and Microsoft Teams notifications using Python](https://www.courier.com/blog/automate-slack-and-microsoft-teams-notifications-using-python/).

This blog is a comprehensive setup guide. If you would like to get started quickly, checkout the code in this [GitHub repository](https://github.com/trycourier/demos/tree/main/automate-slack-teams).

# Before Starting

*   [Get access to your Courier API Key](https://app.courier.com/settings/api-keys)
*   Install [trycourier](https://github.com/trycourier/courier-node) by running the `npm install @trycourier/courier` command

# Send with Slack

**Step 1: Add the Slack integration to Courier**

First, head to the Slack channel in Courier https://app.courier.com/channels/slack and click "Install Provider". If you only want to send with Teams, you can skip to the “Send with Microsoft Teams” section.

![channel slacks](//images.ctfassets.net/z7iqk1q8njt4/SWRZHOpuy16BSC7U6bKZC/7012a8b640279a373385030f5915e783/channel_slack.png)

**Step 2: Create a Slack App**

Navigate to the [Slack Apps](https://api.slack.com/apps) page and log into Slack. Click the **Create an App** button and provide your **App Name** as depicted below.

![slack-app](//images.ctfassets.net/z7iqk1q8njt4/miwFyPxaShQwSo2TOsfAw/9a528f8789cc9e4b2254f6596026167f/image-3.png)

**Step 3: Add OAuth Permission and Scopes**

Define the permissions that your Slack App is authorized to do.

To do so, navigate to the **OAuth & Permissions** page in the sidebar menu and select the following options from the Scopes section:

*   **chat:write**
*   **im:write**
*   **users:read**
*   **users:read.email**

![slack-app-scopes](//images.ctfassets.net/z7iqk1q8njt4/198iG9vhkW4tlkJyeBrpNn/cbf936323438e33685359b7ebc6b4a8b/image-4.png)

Afterward, click the **Install App to Workspace** or **Reinstall App** button at the top of the page. This will generate an output -"Bot User OAuth Token" as depicted below, which will be needed later.

![slack-app-oath-token](//images.ctfassets.net/z7iqk1q8njt4/2EqXlD3eNxgMPsC7HaRbVs/0f34a765a9db3d7c623d59e338a3ad2d/slack-app-oath-token.png)

**Step 4: Send a Slack DM with Node.js**

Add the code snippet below to your codebase (e.g. `index.js` ) and update the following properties:

*   replace `auth-token` with your Courier API key
*   replace `slack_access_token` with the Bot User OAuth Token
*   replace `example@email.com` with your user's email address (this is the email associated with the recipient's Slack Account)
*   Recommended: use your own email for testing

```javascript
const { CourierClient } = require("@trycourier/courier");

const courier = CourierClient({ authorizationToken: "auth_token" });

async function send_message() {
  const { requestId } = await courier.send({
    message: {
      to: {
        slack: {
          access_token: "slack_access_token",
          email: "example@email.com"
        }
      },
      content: {
        title: "Important Survey Reminder",
        body: "This is a reminder to fill out your survey by the end of this week.",
      },
      routing: {
        method: "single",
        channels: ["direct_message"]
      }
    },
  });
  console.log(requestId)
}

send_message()
```

Run the Node.js program to see your notification popup in the user's Slack direct message!

![Slack message](//images.ctfassets.net/z7iqk1q8njt4/7oK2GoJdrfngJoXuqd8DDo/6bb2407eafaf8b4a1ff1cbf978c9ab61/Slack_message.png)

Check your Courier logs for errors if your user did not receive the message.

## Slack Resources

*   [Slack Integration documentation](https://www.courier.com/docs/guides/providers/direct-message/slack/)
*   [Node.js quick start guide](https://www.courier.com/docs/guides/getting-started/nodejs/)
*   [Video walkthrough: Automating Slack Messages with Courier API](https://youtu.be/sZpxo9kOa78)

# Send with Microsoft Teams

We can now try sending the same message via Teams. If you only want to send with Slack, you can skip to the “Routing to multiple channels” section. 

**Step 1: Sign up for a Microsoft 365 Developer Account**

If you do not have a Microsoft 365 developer account, follow the instructions from [this guideline](https://developer.microsoft.com/en-us/microsoft-365/dev-program/) to create an account. If you already have an account, you can skip this step.

**Step 2: Create a Teams App**

Create a new App in Teams. You will need to install the [Developer Portal](https://learn.microsoft.com/en-us/microsoftteams/platform/concepts/build-and-test/teams-developer-portal) from the Team Apps.

After installing the Developer Portal, navigate to the **Apps** tab and click the **New App** button. Then, you will get prompted to enter the application name.

![ms teams add app](//images.ctfassets.net/z7iqk1q8njt4/4aAPZzFGQGiXPs2wvYpv1u/508cbfafe3f3df87b0efed75eb02117a/ms_teams_add_app.png)

After clicking the Add button, you will be redirected to a new window where you can see the App ID. Make sure to copy the App ID for later use.

![MS Teams Bot Basic Info](//images.ctfassets.net/z7iqk1q8njt4/5GqgOocVChW7ODrHXOYiSR/ae5c800f466fa408be455448e0828d24/MS_Teams_Basic_Info.png)

Then, click **App features** from the left menu and click on the tile named **Bot**. It will open a new window for selecting a bot and bot scopes.

![Identify Bot](//images.ctfassets.net/z7iqk1q8njt4/4un7lX2rG9oos1pcte7mXf/c0d66c40799682ffa3e8847ed9d0b265/Identify_Bot.png)

If you do not have a bot created already, follow [these steps](https://learn.microsoft.com/en-us/microsoftteams/platform/resources/bot-v3/bots-create) to create a new one. Also, make sure to save the password generated during the process. Keep the **Messaging endpoint** blank for the moment.

![MS Teams App Configuration](//images.ctfassets.net/z7iqk1q8njt4/2QJEtyIRyEW1IoOjVWc5jT/254f097453ffbda26b71a44b518925a2/MS_Teams_App_Configuration.png)

**Step 3: Deploy the bot**

Now you need to deploy the App to create the messaging endpoint. For that, open the [Microsoft Teams Bot Starter Repo](https://github.com/trycourier/courier-netlify-msteams) and click the Deploy to Netlify button. There, you will have to connect to your GitHub account and enter your App ID (Bot ID), App Password, [Courier Auth Token](https://app.courier.com/settings/api-keys), and a name for the repo.

![Deploy app on netlify](//images.ctfassets.net/z7iqk1q8njt4/1l8TdpjQHBxZyII6wTz1T8/7d595d569310633ec8f8f188b4f08857/image-11.png)

Once the site is deployed, copy your site URL since you need it to finish installing the bot.

**Step 4: Install the bot**

Now, go back to the **Tools > Bot Management** tab in **Developer Portal** and select the created bot to finalize the installation process. There, select the Configure option and copy the site URL to the Bot endpoint address field.

![Bot Endpoint Developer Portal](//images.ctfassets.net/z7iqk1q8njt4/3MSoYstFOcCu92kmVmwTWd/7f4b8dd17db4999c6d0873112a8aca27/Bot_Endpoint_Developer_Portal.png)

Then, select the **Channels** option from the left menu and tick the **Microsoft Teams** option.

![Channels Developer Portal](//images.ctfassets.net/z7iqk1q8njt4/5t8S8x0RqXXaLE6SGIrb31/6174c8f87136d972c2f9e87cba194cd8/Channels_Developer_Portal.png)

**Step 5: Add the Teams integration to Courier**

Now, you need to create a Teams integration in Courier. For that, navigate to the **Channels** tab and select Microsoft Teams from the options. Then, it will show a window like the one below. Enter the **App ID**, **App Password** and click the **Install Provider** button.

![Channel Teams](//images.ctfassets.net/z7iqk1q8njt4/60s7rXRUyYBWby7VaCv4oZ/dd3a0a79a075c791fe3968d5c8a81d92/Channel_Teams.png)![Get link to team](//images.ctfassets.net/z7iqk1q8njt4/5QmeLiEkDVGii3zjF2v7Yr/34011d75428a42c2c3175c6a89337608/image-15.png)

**Step 6: Sending a Simple Teams Notification with Node.js**

Add the code snippet below to your codebase (e.g. index.js ) and update the following properties:

*   replace `auth-token` with your Courier API key
*   `conversation_id`: get the conversation id from threadId query parameter from the URL after opening Microsoft Teams in the browser
*   `service_url`: the service URL associated with that Microsoft Teams tenant (if you are located in the Americas Region, the service url is https://smba.trafficmanager.net/amer)
*   `tenant_id`: go to https://teams.microsoft.com/?tenantId and copying the value from the redirected URL tenantId query parameter, or click the three dots next to your Team and click **Get link to team** to find a link with the tenantId parameter

```javascript
const { CourierClient } = require("@trycourier/courier");

const courier = CourierClient({ authorizationToken: "auth_token" });

async function send_message() {
  const { requestId } = await courier.send({
    message: {
      to: {
        ms_teams: {
          conversation_id: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
          tenant_id: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
          service_url: "https://smba.trafficmanager.net/amer"
        }
      },
      content: {
        title: "Important Survey Reminder",
        body: "This is a reminder to fill out your survey by the end of this week.",
      },
      routing: {
        method: "single",
        channels: ["direct_message"]
      }
    },
  });
  console.log(requestId)
}

send_message()
```

Finally, you can run the Node.js program, and you will see a notification in your Team channel.

Microsoft Teams Resources

*   [Teams Integration documentation](https://www.courier.com/docs/guides/providers/direct-message/microsoft-teams/)
*   [Node.js quick start guide](https://www.courier.com/docs/guides/getting-started/nodejs/)

# Routing to multiple channels

Courier's multi-channel functionality allows you to send notifications across multiple channels, including email, SMS, push notifications, voice, chatbots, and social media platforms, using a single API.

For example, if you want to send an urgent alert to your team, you would use Courier to send this alert as both Slack and Teams notifications.

```javascript
const { CourierClient } = require("@trycourier/courier");

const courier = CourierClient({ authorizationToken: "auth_token" });

async function send_message() {
  const { requestId } = await courier.send({
    message: {
      to: {
        slack: {
          access_token: "access_token",
          email: "example@email.com"
        },
        ms_teams: {
          conversation_id: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
          tenant_id: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
          service_url: "https://smba.trafficmanager.net/amer"
        }
      },
      content: {
        title: "Important Survey Reminder",
        body: "This is a reminder to fill out your survey by the end of this week.",
      },
      routing: {
        method: "all",
        channels: ["direct_message"]
      }
    },
  });
  console.log(requestId)
}

send_message()
```

As you can see below, Courier supports a large selection of Email, SMS, chat, and push notification providers.

![Channels](//images.ctfassets.net/z7iqk1q8njt4/79z4TRaE3a2PunYENuHsUZ/da046abe8e232c15a78af03ee27c5435/channels.png)

We can also send this as an email by adding the `email` property within the `to` object and adding the `”email”` channel to the channels array in the `routing` object.

```javascript
const { CourierClient } = require("@trycourier/courier");

const courier = CourierClient({ authorizationToken: "auth_token" });

async function send_message() {
  const { requestId } = await courier.send({
    message: {
      to: {
        slack: {
          access_token: "access_token",
          email: "example@email.com"
        },
        ms_teams: {
          conversation_id: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
          tenant_id: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
          service_url: "https://smba.trafficmanager.net/amer"
        },
        email: "example@email.com"
      },
      // template: "template_id",
      content: {
        title: "Important Survey Reminder",
        body: "This is a reminder to fill out your survey by the end of this week.",
      },
      routing: {
        method: "all",
        channels: ["direct_message", "email"]
      }
    },
  });
  console.log(requestId)
}

send_message()
```

If you only want to send to the best of these three channels, you can simply change the `method` type from `all` to `single` in the `routing` object. This will send a Slack message. If that fails, it will send a Teams message. If that fails as well, it will send an email.

# Automating Slack and Teams Notifications

If you prefer a visual workflow, you can create an automation template within Courier.

## Create Notification Templates

Head over to the [Notification Designer](https://app.courier.com/designer/notifications) and create a new notification. Once you have created the notification, you will be able to select your channels. Here you can add Slack, Teams, and/or any other channels you would like to send with.

Click on any of the channels to customize your message. Once you have created your message, you can use the drag-and-drop "Library" on the left side to recreate the message for the remaining channels.

![library](//images.ctfassets.net/z7iqk1q8njt4/4t6oJw1bAPc9e52j60bSqV/25db3c6da9ca8b2374ce013186d512d0/library.png)

Click on the settings (gear) icon next to the template name (top right) to access the Notification ID, which you will need later to send this message.

## Building the Automations

The notification template will automatically send to selected channels (based on your template’s channel settings).

[Create a new Automation](https://app.courier.com/automations), select a schedule Trigger, and add a Send step for your notification. We will update the Type to "Date" and Date to the specific date/time this message should be sent.

In the Send step, select JSON and use the Editor to add the recipient information. In the editor, click "+ Add field" and add `slack` as an Object. Then click "+Add nested field" and add `access_token` and `email` with the appropriate values from the code above.

For Teams, click "+ Add field" again and add `ms_teams` as an Object. Then click "+Add nested field" and add `conversation_id`, `tenant_id`, and `service_id`, with the appropriate values from the code above.

This automation will now have the required user profile data to send to both Slack and MS Teams. If you also want to send an email or SMS, edit the JSON object to add a field for `"email"` and `"phone_number"` with the appropriate values.

![automation slack and teams](//images.ctfassets.net/z7iqk1q8njt4/4k88EDNXivmJQYSQIL5C7D/bda0fe85c31f7787c1549daad92afe08/automation_slack_and_teams.png)

# Conclusion

Automating notifications in team communication platforms such as Slack and Teams can significantly improve team productivity and communication. However, building automated notifications from scratch can be complex and time-consuming. That's where Courier comes in with its easy-to-use Node.js SDK that allows developers to send notifications to multiple channels with just a few lines of code.

By following the steps outlined in this article, you can set up notification automation with Courier and Node.js for both Slack and Teams. Additionally, you can leverage Courier's multi-channel functionality to integrate other applications and channels into your notification system.

# FAQs

**1. What is Courier?**

[Courier](https://www.courier.com/) connects communication APIs, data, and development tools that your team already uses to deliver a best-in-class notification system that will trigger messages from your app at just the right time, using just the right channel. It provides powerful API primitives and reusable UI components for building, plus no-code tools for designing templates and communication sequences.

**2. What is Slack?**

Slack is a cloud-based messaging platform that enables teams to communicate and collaborate in real-time. It is known for its user-friendly interface and extensive third-party integrations, making it a highly customizable platform for teams of all sizes. Slack allows users to easily organize their conversations into channels, share files, and collaborate with other team members. It also offers multiple app integrations, including project management and automation tools.

**3. What is Microsoft Teams?**

Microsoft Teams is another popular communication and collaboration platform that is part of the Microsoft Office 365 suite. It enables teams to chat, share files, and collaborate in real time, both synchronously and asynchronously. With features such as video conferencing, screen sharing, and group chats, Microsoft Teams is ideal for businesses and organizations that require a comprehensive and centralized collaboration platform.

**4. Missing Provider Support error message**

If your message did not go through, check your Courier logs. For a "MISSING\_PROVIDER\_SUPPORT" error message, you will need to double-check if the Slack and/or  Teams channels were installed properly in Courier. Try removing the channel(s) (go to the channel and click "Remove Channel" at the bottom of the page) that is causing the error and then adding it again.


automate-slack-msteams-nodejs-header

Automate messages via Slack, MS Teams, and any other channel of your choice from your Node.js applications.

automate-slack-msteams-nodejs-thumbnail

Automate Slack and MS Teams Notifications using Node.js

Messaging apps are essential for internal collaboration and critical notifications such as reminders, alerts, and other time-sensitive updates. While integrating with the Slack and Microsoft APIs is fairly straightforward, implementing these tools as a part of a full-featured notification system that embeds with your app experience can be far more daunting.

In this article, we'll show you how to send notifications via Slack and Microsoft Teams, using Courier to make these tools a seamless part of how your app communicates with users.

# Prerequisites

*   [Get access to your Courier API Key](https://app.courier.com/settings/api-keys)
*   Install [Python 3.x](https://www.python.org/downloads/) on your computer
*   Install [trycourier](https://github.com/trycourier/courier-python) by running the `pip install trycourier` command

# Create a Notification Template for Slack and Teams

Head over to the [Notification Designer](https://app.courier.com/designer/notifications) and create a new notification. Once you have created the notification, you will be able to select your channels. Here you can add Slack, Teams, and/or any other channels you would like to send with.

Click on any of the channels to customize your message. Once you have created your message, you can use the drag-and-drop "Library" on the left side to recreate the message for the remaining channels.

![library](//images.ctfassets.net/z7iqk1q8njt4/4t6oJw1bAPc9e52j60bSqV/25db3c6da9ca8b2374ce013186d512d0/library.png)

Click on the settings (gear) icon next to the template name (top right) to access the Notification ID, which you will need later to send this message.

# Send with Slack

**Step 1: Add the Slack integration to Courier**

First, head to the Slack channel in Courier https://app.courier.com/channels/slack and click "Install Provider". If you only want to send with Teams, you can skip to the “Send with Microsoft Teams” section.

![channel slacks](//images.ctfassets.net/z7iqk1q8njt4/SWRZHOpuy16BSC7U6bKZC/7012a8b640279a373385030f5915e783/channel_slack.png)

**Step 2: Create a Slack App**

Navigate to the [Slack Apps](https://api.slack.com/apps) page and log into Slack. Click the **Create an App** button and provide your **App Name** as depicted below.

![slack-app](//images.ctfassets.net/z7iqk1q8njt4/miwFyPxaShQwSo2TOsfAw/9a528f8789cc9e4b2254f6596026167f/image-3.png)

**Step 3: Add OAuth Permission and Scopes**

Define the permissions that your Slack App is authorized to do.

To do so, navigate to the **OAuth & Permissions** page in the sidebar menu and select the following options from the Scopes section:

*   **chat:write**
*   **im:write**
*   **users:read**
*   **users:read.email**

![slack-app-scopes](//images.ctfassets.net/z7iqk1q8njt4/198iG9vhkW4tlkJyeBrpNn/cbf936323438e33685359b7ebc6b4a8b/image-4.png)

Afterward, click the **Install App to Workspace** or **Reinstall App** button at the top of the page. This will generate an output -"Bot User OAuth Token" as depicted below, which will be needed later.

![slack-app-oath-token](//images.ctfassets.net/z7iqk1q8njt4/2EqXlD3eNxgMPsC7HaRbVs/0f34a765a9db3d7c623d59e338a3ad2d/slack-app-oath-token.png)

**Step 4: Send a Slack DM with Python**

Add the code snippet below to your codebase (e.g. `index.py` ) and update the following properties:

*   replace <auth-token> with your Courier API key
*   `access_code`: replace `xoxb-abcd` with the Bot User OAuth Token
*   replace `example@gmail.com` with your user's email address (this is the email associated with the recipient's Slack Account)
*   Recommended: use your own email for testing
*   replace `85S5NWXJVQ4GN8J21JSKV3JVCSV2` with your Notification ID from the first part of this tutorial

```mikrotik
from trycourier import Courier
client = Courier(auth_token="<auth-token>")

resp = client.send_message(
  message={
    "to": {
      "slack": {
        "access_token": "xoxb-abcd",
        "email": "example@gmail.com",
      },
    },
    "template": "85S5NWXJVQ4GN8J21JSKV3JVCSV2",
    "data": {
    },
  }
)
print(resp['requestId'])

```

Execute the Python script to see your notification popup in the user's Slack direct message!

![Slack message](//images.ctfassets.net/z7iqk1q8njt4/7oK2GoJdrfngJoXuqd8DDo/6bb2407eafaf8b4a1ff1cbf978c9ab61/Slack_message.png)

Check your Courier logs for errors if your user did not receive the message.

## Slack Resources

*   [Slack Integration documentation](https://www.courier.com/docs/guides/providers/direct-message/slack/)
*   [Python quick start guide](https://www.courier.com/docs/guides/getting-started/python/)
*   [Video walkthrough: Automating Slack Messages with Courier API](https://youtu.be/sZpxo9kOa78)

# Send with Microsoft Teams

We can now try sending the same message via Teams. If you only want to send with Slack, you can skip to the “Routing to multiple channels” section. 

**Step 1: Sign up for a Microsoft 365 Developer Account**

If you do not have a Microsoft 365 developer account, follow the instructions from [this guideline](https://developer.microsoft.com/en-us/microsoft-365/dev-program/) to create an account. If you already have an account, you can skip this step.

**Step 2: Create a Teams App**

Create a new App in Teams. You will need to install the [Developer Portal](https://learn.microsoft.com/en-us/microsoftteams/platform/concepts/build-and-test/teams-developer-portal) from the Team Apps.

After installing the Developer Portal, navigate to the **Apps** tab and click the **New App** button. Then, you will get prompted to enter the application name.

![ms teams add app](//images.ctfassets.net/z7iqk1q8njt4/4aAPZzFGQGiXPs2wvYpv1u/508cbfafe3f3df87b0efed75eb02117a/ms_teams_add_app.png)

After clicking the Add button, you will be redirected to a new window where you can see the App ID. Make sure to copy the App ID for later use.

![MS Teams Bot Basic Info](//images.ctfassets.net/z7iqk1q8njt4/5GqgOocVChW7ODrHXOYiSR/ae5c800f466fa408be455448e0828d24/MS_Teams_Basic_Info.png)

Then, click **App features** from the left menu and click on the tile named **Bot**. It will open a new window for selecting a bot and bot scopes.

![Identify Bot](//images.ctfassets.net/z7iqk1q8njt4/4un7lX2rG9oos1pcte7mXf/c0d66c40799682ffa3e8847ed9d0b265/Identify_Bot.png)

If you do not have a bot created already, follow [these steps](https://learn.microsoft.com/en-us/microsoftteams/platform/resources/bot-v3/bots-create) to create a new one. Also, make sure to save the password generated during the process. Keep the **Messaging endpoint** blank for the moment.

![MS Teams App Configuration](//images.ctfassets.net/z7iqk1q8njt4/2QJEtyIRyEW1IoOjVWc5jT/254f097453ffbda26b71a44b518925a2/MS_Teams_App_Configuration.png)

**Step 3: Deploy the bot**

Now you need to deploy the App to create the messaging endpoint. For that, open the [Microsoft Teams Bot Starter Repo](https://github.com/trycourier/courier-netlify-msteams) and click the Deploy to Netlify button. There, you will have to connect to your GitHub account and enter your App ID (Bot ID), App Password, [Courier Auth Token](https://app.courier.com/settings/api-keys), and a name for the repo.

![Deploy app on netlify](//images.ctfassets.net/z7iqk1q8njt4/1l8TdpjQHBxZyII6wTz1T8/7d595d569310633ec8f8f188b4f08857/image-11.png)

Once the site is deployed, copy your site URL since you need it to finish installing the bot.

**Step 4: Install the bot**

Now, go back to the **Tools > Bot Management** tab in **Developer Portal** and select the created bot to finalize the installation process. There, select the Configure option and copy the site URL to the Bot endpoint address field.

![Bot Endpoint Developer Portal](//images.ctfassets.net/z7iqk1q8njt4/3MSoYstFOcCu92kmVmwTWd/7f4b8dd17db4999c6d0873112a8aca27/Bot_Endpoint_Developer_Portal.png)

Then, select the **Channels** option from the left menu and tick the **Microsoft Teams** option.

![Channels Developer Portal](//images.ctfassets.net/z7iqk1q8njt4/5t8S8x0RqXXaLE6SGIrb31/6174c8f87136d972c2f9e87cba194cd8/Channels_Developer_Portal.png)

**Step 5: Add the Teams integration to Courier**

Now, you need to create a Teams integration in Courier. For that, navigate to the **Channels** tab and select Microsoft Teams from the options. Then, it will show a window like the one below. Enter the **App ID**, **App Password** and click the **Install Provider** button.

![Channel Teams](//images.ctfassets.net/z7iqk1q8njt4/60s7rXRUyYBWby7VaCv4oZ/dd3a0a79a075c791fe3968d5c8a81d92/Channel_Teams.png)![Get link to team](//images.ctfassets.net/z7iqk1q8njt4/5QmeLiEkDVGii3zjF2v7Yr/34011d75428a42c2c3175c6a89337608/image-15.png)

**Step 6: Sending a Simple Teams Notification with Python**

Add the code snippet below to your codebase (e.g. index.py ) and update the following properties:

*   replace `<auth-token>` with your Courier API key
*   `conversation_id`: get the conversation id from threadId query parameter from the URL after opening Microsoft Teams in the browser
*   `service_url`: the service URL associated with that Microsoft Teams tenant (if you are located in the Americas Region, the service url is https://smba.trafficmanager.net/amer)
*   `tenant_id`: go to https://teams.microsoft.com/?tenantId and copying the value from the redirected URL tenantId query parameter, or click the three dots next to your Team and click **Get link to team** to find a link with the tenantId parameter

```mikrotik
from trycourier import Courier
client = Courier(auth_token="<auth-token>")

resp = client.send_message(
  message={
      "to": {
      "ms_teams": {
          "conversation_id": "Yl2wJmlmFQkc65UAg0I2kJyCnPJlXvIM4Q3XSrDBZnQ1",
          "tenant_id": "aac0c564-6c5e-4b05-8dc3-408087f77f76",
          "service_url": "https://smba.trafficmanager.net/amer",
      },
      },
      "template": "M79W7S9TRYM04CM634A805T8SYKM",
      "data": {
      },
  } 
)
print(resp['requestId'])
```

Finally, you can run the python script, and you will see a notification in your Team channel.

Microsoft Teams Resources

*   [Teams Integration documentation](https://www.courier.com/docs/guides/providers/direct-message/microsoft-teams/)
*   [Python quick start guide](https://www.courier.com/docs/guides/getting-started/python/)

# Routing to multiple channels

Courier's multi-channel functionality allows you to send notifications across multiple channels, including email, SMS, push notifications, voice, chatbots, and social media platforms, using a single API.

For example, if you want to send an urgent alert to your team, you would use Courier to send this alert as an email, as well as a Slack or Teams notification. As you can see below, Courier supports a large selection of Email, SMS, chat, and push notification providers.

![Channels](//images.ctfassets.net/z7iqk1q8njt4/79z4TRaE3a2PunYENuHsUZ/da046abe8e232c15a78af03ee27c5435/channels.png)

Let’s update the notification template to send across four channels: email, SMS, Slack, and Teams. First, add email and SMS channels to the template and make sure they both also have the same content as the previous two (remember, you can use the Library to drop in pre-built content blocks).

Next, update the Settings of each channel so that “Always send to” is toggled on (away from “Best Of”) for each of the four channels listed.

![Always send to Slack](//images.ctfassets.net/z7iqk1q8njt4/4FHXzgaBVw4lgmvaSjJCyo/ee47ec3c01f60b41b6620d30b44b2b7f/Always_send_to.png)

```python
from trycourier import Courier
client = Courier(auth_token="<auth-token>")

resp = client.send_message(
  message={
    "to": {
      "slack": {
        "access_token": "xoxb-abcd",
        "email": "example@gmail.com",
      },
      "ms_teams": {
          "conversation_id": "85S5NWXJVQ4GN8J21JSKV3JVCSV2",
          "tenant_id": "aac0c564-6c5e-4b05-8dc3-408087f77f76",
          "service_url": "https://smba.trafficmanager.net/amer",
      },
    },
    "template": "Z5N9D2J8DSMBKEHWF27AEEF6J822"
  }
)
print(resp['requestId'])
```

![Four channels](//images.ctfassets.net/z7iqk1q8njt4/4BUpIEvF4twcNx4POd0sO0/58b2c3859e8fb57a0b270d1bdcc238df/Four_channels.png)

You can also decide whether you actually want to send to all four channels or only specific ones. “Best of” means that Courier will send to one channel out of all that are listed. E.g. if you list Slack as “Always send to”, but have email and SMS as “Best of”, Courier will send a Slack message and attempt to send an email. If the email fails to deliver for any reason, Courier will then reroute to SMS. This means it will only send an SMS if and when email fails.

# Automating Slack and Teams Notifications

## Automating Slack notifications

If you prefer a visual workflow, you can create an automation template within Courier.

[Create a new Automation](https://app.courier.com/automations), select a schedule Trigger, and add a Send step for your notification. We will update the Type to "Date" and Date to the specific date/time this message should be sent.

In the Send step, select JSON and use the Editor to add the recipient information. In the editor, click "+ Add field" and add slack as an Object. Then click "+Add nested field" and add `access_token` and `email` with the appropriate values from the code above.

![Update automation JSON](//images.ctfassets.net/z7iqk1q8njt4/5mGTvwwLzJJkdFJC9s0a2K/d4d299365be7cf11823824f5866ff6b6/automation_2.png)

## Automating Teams notifications

The notification template will automatically send to all selected channels.

Head over to the Automation and, in the JSON editor of the Send step, click "+ Add field" and add ms\_teams as an Object. Then click "+Add nested field" and add `conversation_id`, `tenant_id`, and `service_id`, with the appropriate values from the code above.

This automation will now have the required user profile data to send to both Slack and MS Teams. If you also want to send to an email or SMS, edit the JSON object to add field for `"email"` and `"phone_number"` with the appropriate values.

# Conclusion

Automating notifications in team communication platforms such as Slack and Teams can significantly improve team productivity and communication. However, building automated notifications from scratch can be complex and time-consuming. That's where Courier comes in with its easy-to-use Python SDK that allows developers to send notifications to multiple channels with just a few lines of code.

By following the steps outlined in this article, you can set up notification automation with Courier and Python for both Slack and Teams. Additionally, you can leverage Courier's multi-channel functionality to integrate other applications and channels into your notification system.

# FAQs

**1. What is Courier?**

[Courier](https://www.courier.com/) connects communication APIs, data, and development tools that your team already uses to deliver a best-in-class notification system that will trigger messages from your app at just the right time, using just the right channel. It provides powerful API primitives and reusable UI components for building, plus no-code tools for designing templates and communication sequences.

**2. What is Slack?**

Slack is a cloud-based messaging platform that enables teams to communicate and collaborate in real-time. It is known for its user-friendly interface and extensive third-party integrations, making it a highly customizable platform for teams of all sizes. Slack allows users to easily organize their conversations into channels, share files, and collaborate with other team members. It also offers multiple app integrations, including project management and automation tools.

**3. What is Microsoft Teams?**

Microsoft Teams is another popular communication and collaboration platform that is part of the Microsoft Office 365 suite. It enables teams to chat, share files, and collaborate in real time, both synchronously and asynchronously. With features such as video conferencing, screen sharing, and group chats, Microsoft Teams is ideal for businesses and organizations that require a comprehensive and centralized collaboration platform.

**4. Missing Provider Support error message**

If your message did not go through, check your Courier logs. For a "MISSING\_PROVIDER\_SUPPORT" error message, you will need to double-check if the Slack and/or  Teams channels were installed properly in Courier. Try removing the channel(s) (go to the channel and click "Remove Channel" at the bottom of the page) that is causing the error and then adding it again.

Screenshot of Courier Automation scheduling message with Slack and MS Team

automate-slack-msteams-header

How to send and automate notifications via Slack and Microsoft Teams, using Courier to make these tools a seamless part of how your app communicates with users.

automate-slack-msteams-thumbnail

Automate Slack and Microsoft Teams Notifications using Python

## Before Starting
GitHub Repository: [https://github.com/shreythecray/infiltration](https://github.com/shreythecray/infiltration)

**The hackathon ends soon,** and we are giving away over $1K in prizes! Join us in building a cool project and winning any of the following prizes. 🏆

- **Courier Hacks 1st Place:** Top submission for use for notifications and demonstration of proper app-to-user notifications with the Courier API will receive $1000 via Zelle or PayPal.
- **Courier Hacks 2nd Place:** 2nd Place submission for use for notifications and demonstration of proper app-to-user notifications with the Courier API will receive the Apple AirPods Pro.
- **Public Favorite:** Public favorite winner will receive a Keychron Keyboard.
- **Runners-Up:** Runners-up submissions will receive a Hydro Flask.

Additionally, everyone who submits a project successfully integrating the Courier API will receive a $20 Amazon gift card! Submissions close on **September 28th**. Register now to submit this project for a chance to win some cool prizes.

Register for the Hackathon: [https://courier-hacks.devpost.com/](https://courier-hacks.devpost.com/)

Not sure where to start? In this tutorial, we will create a Discord bot that sends daily automated messages encrypted in Morse code with Node.js and the Courier API.

## What is Going On?

### Recap
We are secret agents, and we previously built an application to send secret messages encrypted in Morse code to communicate with our spy network. [Learn more >](https://www.courier.com/blog/hackathon-courier-api-nodejs/)

Last time, headquarters told us that one of our spies had leaked sensitive, top-secret information to our enemies, so we built a lie detector that alerted our spy network when we identified the mole. We used Azure's Cognitive Services to perform facial recognition on everyone on our team and Courier to broadcast the identity of the mole to our spy network. [Learn more >](https://www.courier.com/blog/serverless-lie-detector-facial-recognition/)

### What’s Next:
We have successfully identified the mule and have alerted our spy network! In an unfortunate turn of events, the mule happens to be our partner, Agent X, and now we are being suspected as a traitor as well. Since we are highly skilled, Headquarters knows that the Lie Detector won’t work on us, but we have been placed off-duty until we can prove that we are innocent.

Before we were removed from duty, we were able to use the Lie Detector to find out that the enemy had thousands of civilians under control in a secret Discord server. The civilians are being brainwashed with enemy propaganda every day. To prove our innocence, we decide to go undercover and infiltrate the enemy’s Discord server. With the help of Agent X, we have been added to the server as an administrator. Our plan is to create and install a Discord bot that automates encrypted messages to the civilians and alerts them about the situation so that they can escape.

## Let’s Build

### Pre-reqs:
- Admin access to a Discord server
- A cool undercover Agent name for our Discord bot
- Optional: a cool undercover Agent profile picture for our Discord bot

### Part 1: Set Up Node.js Project
Today, we will be building this with Node.js. If you’re curious about how to build this project using Ruby, cURL, Powershell, Go, PHP, Python, or Java, let us know: `https://discord.com/invite/courier`. You can also access code for these within our [API reference](https://www.courier.com/docs/reference/automation/invoke/). Let’s get started:

- Create a new project folder.
- Create three new files: “index.js”, “.env”, and “.gitignore”.
- Install [dotenv npm package](https://www.npmjs.com/package/dotenv) to store variables: `npm install dotenv --save`

    Import and configure dotenv by adding to top of index.js: `require("dotenv").config();`

- Similarly, install [node-fetch npm package](https://www.npmjs.com/package/node-fetch) to make API calls: `npm install node-fetch@2`

    Import and configure node-fetch by adding to top of index.js: `const fetch = require("node-fetch");`

### Part 2: Create a Discord Bot
- [Sign up for (or log into) Courier >](https://courier.com/hack-now)
- Open Discord provider in Channels. Here we will need our Discord bot token to continue.
- In order to access a Discord bot token, we’ll create a Discord application and add a Discord bot.
    - Click on “New Application” within the [Discord Developer Dashboard](https://discord.com/developers/applications).
    - Type the app’s name and click “Create”.
    - In the left menu, open the “Bot” page and click “Add Bot”. We can update the icon and username (bot icon file can be found in the GitHub linked above).
- Once the bot has been created, copy the bot token provided and paste it in Courier (make sure to keep this token private).
- We will need to give this application permission to post as the bot within our server. Check out the [Bot permissions documentation](https://discord.com/developers/docs/getting-started#adding-scopes-and-permissions).
    - Within the application, head over to OAuth2 and click on URL generator
    - Select the `bot` scope
    - Select the following permissions: `View Channels`, `Send Messages`, and `Read Message History`
    - Go to the generated URL below. This URL will invite the bot to the server and authorize it with the permissions chosen.
- On Discord, click on User Settings (next to username on the bottom left). Access the Advanced settings page and enable Developer Mode ✅.
- Back in the Discord server, right click on the channel and copy the channel ID (bottom of list). Add this as the value of `channelID` in the .env file within the project and save it as a variable within the index.js file:

    ```json
    const channelID = process.env.channelID
    ```

Now, Courier has access to sending messages to this server as the bot.

### Part 3: Send Messages
- Create a new notification within the [Notification Designer](https://app.courier.com/designer)
- Add the Chat notification channel with Discord as the provider
- Select on the Chat channel on the right to edit the message

![image6](//images.ctfassets.net/z7iqk1q8njt4/5VaUY0gl7ILbrIf5I6ib3x/c579d27b7ec6c0f0782ffbc71bd3c25f/image6.gif)

- Write and publish the message. We need to create a clear message that will indicate to our civilians how to escape. Our message will be: `Run while you can. You can find shelter here: https://discord.com/invite/courier.`
- Copy the notification template ID from the notification’s settings and add it as the value of `templateID` in the .env file within the project and save it as a variable within the index.js file:

    ```json
    const templateID = process.env.templateID
    ```

![image3](//images.ctfassets.net/z7iqk1q8njt4/3uNICG76LUrNFmJ8XWzkfw/6774fa85e51e866436c82957ad6353ce/image3.gif)

- Create a test event and replace the `channel_id` in the JSON with the `channel_id` we received from Discord earlier.

    ```json
    {
      "courier": {},
      "data": {},
      "profile": {
        "discord": {
          "channel_id": "768866348853383208"
        }
      },
      "override": {}
    }
    ```

- Test a message to ensure that the Discord provider integration is working correctly.

![image4](//images.ctfassets.net/z7iqk1q8njt4/5GfnsGxTYn4iEAhKnheqIb/41c562b0811dbac8dae8bf3bfe7f60ec/image4.gif)

- Replace the message with a variable `{secretMessage}` so that, later, we can edit the message from our code directly.

![image2](//images.ctfassets.net/z7iqk1q8njt4/RBa7sDpfdeamGi1b2WpoV/57ccc96254356889c55da8676b732d15/image2.png)

### Part 4: Encrypt Message with the Morse API
- Create an asynchronous function called `encryptMessage()`, which takes `originalMessage` as a parameter. This function will call the Morse API, which will allow us to translate any message from English to Morse code. The enemy will have to spend more time and resources into decrypting our messages, which will give our civilians time to escape from the server.

    ```jsx
    async function encryptMessage(originalMessage) {
    }
    ```

- Let’s define the GET API call options:

    ```jsx
    const morseOptions = {
    	method: 'GET',
    	headers: {
    		Accept: 'application/json',
    		'Content-Type': 'application/json'
    	}
    };
    ```

- We need to attach the `originalMessage` function parameter to the Morse API endpoint:

    ```json
    const morseEndpoint = "https://api.funtranslations.com/translate/morse.json?text="+originalMessage
    ```

- We need to be able to access the translation from this API call in the body of the Courier API call. To call the API, we can use node-fetch as we did before.
    - Create a variable called `morseResponse`, which will hold the entire response from this call.
    - Convert the JSON object into a JavaScript object `morseResponseJSON` so that we can read it within our code.
    - Get the translated message out of that object and save it in a new variable called `encryptedMessage`.
    - Return `encryptedMessage` so that we can call this function to access it elsewhere.

    ```jsx
    const morseResponse = await fetch(morseEndpoint, morseOptions);
    const morseResponseJSON = await morseResponse.json();
    const encryptedMessage = morseResponseJSON.contents.translated;
    console.log(encryptedMessage);
    return encryptedMessage;
    ```

![image1](//images.ctfassets.net/z7iqk1q8njt4/3xp8SErhajuhxiMVB2iX2W/43ce98adc0c2c64ca833e46e304b7779/image1.png)

*NOTE: The Morse API has a rate limit, which may give you an error if you run it too many times within the hour. In this case, you will have to wait for some time before continuing.*

### Part 5: Automate Messages
[Learn about Automations >](https://www.courier.com/docs/automations/)

[Check out the Automations API reference >](https://www.courier.com/docs/reference/automation/invoke/)

- Create a new asynchronous function called `runDiscordAutomation()`, which will call the `encryptMessage()` function to translate a message and use the Courier API to automatically send messages to the enemy Discord server everyday.

    ```
    async function runDiscordAutomation() {
    }
    ```

- Before we can run our message through the Morse translation API, we need to ensure that it is in the correct format, with all spaces converted into their URL encoding, `%20` as shown below. We can call `encryptMessage()` with `originalMessage` as a parameter to translate it. `encryptedMessage` will evaluate as the translated message.

    ```jsx
    const originalMessage = "run%20while%20you%20can%20you%20can%20find%20shelter%20here";
    const encryptedMessage = await encryptMessage(originalMessage);
    ```
- Add the link to the safe server in the notification template within the designer: “[https://discord.com/invite/courier](https://discord.com/invite/courier)”

- Let’s define the Courier Automation endpoint and options. Here we will need access to our Courier API Key, which can be found within the [Courier Settings page](https://app.courier.com/settings/api-keys). Save the first value in the .env file as apiKey and access it in this file as process.env.apiKey.

    ```jsx
    const automationsEndpoint = "https://api.courier.com/automations/invoke"

    const courierOptions = {
    	method: "POST",
    	headers: {
    		Accept: "application/json",
    		"Content-Type": "application/json",
    		Authorization: 'Bearer ' + process.env.apiKey
    	},
    	body: JSON.stringify({
    		//next steps
    	}),
    };
    ```

- The body object within the options will encompass two objects: `automation` and `data`

    ```json
    body: JSON.stringify({
    	"automation": {
    	},
    	"data": {
    	} 
    }),
    ```

    - The `automation` object will include a `steps` array, which will consist of all steps required for the automation. Our automation consists of reminders that are sent once a day - in this case we will be adding three steps: a send step, a delay, and another send step (so on).

        ```json
        "automation": {
        	"steps": [],
        },
        ```

    - Each step will need to be defined with two objects: the type of `action` (send, delay, cancel, etc.) and `message`. The `message` consists of the notification template ID (we saved this in the .env file earlier) and information about where this message is being sent. A Discord message requires either a `user_id` or a `channel_id`. In order to reach as many innocent civilians as possible, as quickly as possible, we will directly send messages in a channel.
    - This is what the send and delay steps would look like:

        ```json
        {
        	"action": "send",
        	"message": {
        		"template": templateID,
        		"to": {
        			"discord": {
        				"channel_id": process.env.channelID
        			}
        		}
        	}
        },
        ```

        ```json
        {
        	"action": "send",
        	"duration":"1 day"
        },
        ```

    - The data object would need to contain the `encryptedMessage`:

        ```jsx
        "data": {
        	"secretMessage": encryptedMessage
        }
        ```

    - [Learn more about sending to a channel via Courier >](https://www.courier.com/docs/guides/providers/direct-message/discord/#sending-a-message-to-a-channel)
- For testing purposes, it’s easier to either remove 1 delay step or keep it at a short period like `1 minute`
- Finally, we can use node-fetch again to call the Automations API and trigger this automation

    ```jsx
    fetch(automationsEndpoint, courierOptions)
        .then((response) => response.json())
        .then((response) => console.log(response))
        .catch((err) => console.error(err));
    ```

![image5](//images.ctfassets.net/z7iqk1q8njt4/DToIls5IJymsGD2WVpqNr/1eff78ca95f8a643f6bfbcab2cfc3cdc/image5.png)

## Conclusion

Our Discord bot is ready to save some civilians. Try building a Discord bot of your own and tweet a screenshot of your Courier automated messages in action, and we will send a gift to the first three Secret Agents to complete this task! Head to [courier.com/hack-now](http://courier.com/hack-now) to get started. Don’t forget to submit your project to our [Hackathon](https://courier-hacks.devpost.com/) for a chance to win over $1000 in cash and prizes!

### Quick Links

🔗 GitHub Repository: [https://github.com/shreythecray/infiltration](https://github.com/shreythecray/infiltration)

🔗 Courier: [app.courier.com](https://bit.ly/3QPiFg3)

🔗 Register for the Hackathon: [https://courier-hacks.devpost.com/](https://courier-hacks.devpost.com/)

🔗 Discord Application and Bot Guide: [https://discord.com/developers/docs/getting-started](https://discord.com/developers/docs/getting-started)

🔗 Courier Discord Provider Docs: [https://www.courier.com/docs/guides/providers/direct-message/discord/](https://www.courier.com/docs/guides/providers/direct-message/discord/)

🔗 Courier Automations Docs: [https://www.courier.com/docs/automations/](https://www.courier.com/docs/automations/)

🔗 Courier Automations API Reference: [https://www.courier.com/docs/reference/](https://www.courier.com/docs/reference/)


Brunette woman (spy) sits at a desk, hacking a computer.

serverless-lie-detector-header

Our plan is to create and install a Discord bot that automates encrypted messages to the civilians and alerts them about the situation so that they can escape.

serverless-lie-detector-thumbnail

Create a Discord Bot that Automates Secret Messages with Node.js

Build a Serverless lie detector that uses AI for facial recognition (with Node.js, Azure Functions, Azure Face API, and Courier API)

Courier [Tutorial]

Build your first notification in minutes

Build your first notification in minutes

Product

Developers

Resources

Company