Forem: Courier

Sending Scheduled and Recurring Email Notifications with PHP

Oleksii Klochai — Thu, 27 Jul 2023 11:01:32 +0000

Sending timely targeted email notifications greatly affects how your audience engages with your product. For these notifications to be effective at notifying your users of key events, you need to schedule when they are sent so that they are delivered at the right time.

Scheduled and recurring notifications are in use everywhere — for example, online stores use scheduled notifications to inform users about sale events (like Black Friday), and doctors, dentists, and tradespeople have systems that send appointment reminders. Recurring emails are commonly used for subscription services to email monthly bills to customers.

This tutorial covers two different ways for PHP developers to send scheduled and recurring email notifications through the Courier notification platform using its PHP SDK. It also offers a low-code solution for sending scheduled emails using just the Courier UI. Courier is a multi-channel notification service with a robust API, which you can use to build a production-ready email notification system in a few minutes.

Configure an email service provider in Courier

Create a Courier account if you don’t already have one, so that you can configure an email service provider in Courier, allowing it to send emails on your behalf. \

In the Courier app, navigate to Channels and choose your email service provider. For this tutorial, we will use Gmail.

On the next screen, select Sign in with Google to give Courier permission to access your Gmail account.

Create a notification template in Courier

Courier uses email templates to make it easy to reuse your emails. In this tutorial, we will use an example of a hairdressing business that sends emails to its clients before (and sometimes after) appointments.

To create your first template, start by navigating to the Designer. Click Create Template, give it the name Hair appointment reminder, and click Create Template again.

Next, select Email as the channel for this notification (choosing Gmail as the specific provider in the drop-down box). Now, click on your new email channel on the left side to see the no-code editor for designing your notification.

Give your notification the subject “Hair appointment reminder”, and paste the following content into the message body:

Dear {name},

This email is to confirm your upcoming hair appointment tomorrow.

We look forward to seeing you at {place}. Please arrive five minutes before your appointment start time.

If you need to reschedule, please let us know at least 24 hours prior to your appointment time.

Thank you for your appointment.

The {salonName} Team

The curly braces in this template are variables that will later be passed to the template as data. Now that your template is complete, click Publish Changes. Later on, you will need your notification template ID and Courier authorization token when you want to call the Courier API. These are both available in your notification template settings. Navigate there now and copy both so that you can use them later.

Now you have three options:

Directly send scheduled or recurring emails using Courier*:* Call the sendEnhancedNotification() function from the Courier PHP SDK, and use a third party task scheduling library called Crunz to deal with the scheduling side of things. This works using cron syntax, so the same principle can be used for scheduled or recurring emails.
Use Courier’s automations to add send logic to your scheduled emails: An automation in Courier is a way of chaining together different steps such as the sending of emails (or other notification-related logic) so that the steps happen in a particular order. An automation can be run by calling the invokeAutomation()function, and as with option 1, you can use Crunz to deal with the scheduling.
Using Courier’s no-code automations designer: This is a no-code GUI tool in the Courier UI that uses a drag-and-drop canvas to build up your notification logic. It contains some more advanced logic than option 2 (such as the ability to create email digests or batching).

Option 1: directly send a scheduled or recurring email using Courier

Preparing your PHP environment

For both of the PHP examples shown below, you will need to prepare a PHP environment and create a notification template in the Courier app.

Install the latest versions of PHP and Composer.
Install the following packages using Composer:
- trycourier/courier — the Courier PHP SDK
- guzzlehttp/guzzle — required by the Courier PHP SDK
- crunzphp/crunz — for scheduling one-time and recurring tasks
- vlucas/phpdotenv — for handling environment variables

You can install these by running the following command:

composer require crunzphp/crunz vlucas/phpdotenv trycourier/courier guzzlehttp/guzzle

You can also find the code shown in this tutorial in our working example repository on GitHub. If you are cloning the repository, you will need to run the composer install command to install the dependencies.

Sending a scheduled email

To manage the scheduling side of things, we will use Crunz — a PHP package that allows you to run scheduled tasks within your PHP code without having to create a cron job for each of them. We will wrap this around Courier’s sendEnhancedNotification() function, which is used for sending emails.

For this example, we have specified that the hair appointment reminder should be sent at a specific time (13:30 2023-07-01). However, note that Crunz’s on() function accepts any date format parsed by PHP's strtotime() function, so it’s easy to pass in a time value derived from one of your variables.

As per the example in our GitHub repository, you must provide your configuration in an .env file at the project root. You can create this file by copying the provided example file into your project directory:

cp .env.example .env

Then, fill out the contents of the newly copied .env file:

COURIER_AUTHORIZATION_TOKEN	Courier API key, found in Settings
TEST_EMAIL_TO	Use your own email address as the value
TEST_DIRECT_SEND_NOTIFICATION_TEMPLATE_ID	The notification template ID for the “Hair appointment reminder” email template

Crunz requires you to add a single crontab entry that runs every minute. Whenever this job runs, any tasks scheduled using Crunz for that time will be executed. You only need to do this once for your project. Append the following line to your own user’s crontab on your PHP server (you can do this by typing crontab -e in your terminal):

* * * * * cd /path/to/project && vendor/bin/crunz schedule:run

Replace /path/to/project with the absolute path to your PHP project. For security reasons, you should not add this line to your root user's crontab but instead create a user who has execute permissions for the project directory or is a member of the group that your web server runs under (by default, www-data on most Linux systems).

Crunz requires the presence of a configuration file, which contains a configured timezone. Create this by running this command in your project directory:

vendor/bin/crunz publish:config

Note that the default configured timezone is UTC, but you can change this in the config if needed.

All Crunz tasks must be contained in a directory called tasks at the root level of your project. The file containing each task should end with Tasks.php. Create this directory, and inside it, create a file called scheduledSendTasks.phpand paste the following code into it:

<?php

use Crunz\Schedule;
use Courier\CourierClient;
use Dotenv\Dotenv;

// Configure environment variables - set the .env directory to the parent of the Tasks directory
// Environment variables are stored in a variable so that they can be passed to the scheduled task, which will not have access to the current global namespace
$dotenv = Dotenv::createArrayBacked(__DIR__ . "/..")->load();

// Configure scheduler
$schedule = new Schedule();

// Configure the Courier PHP SDK - note the first null is the API path, of which we will use the default
$courier = new CourierClient(null, $dotenv['COURIER_AUTHORIZATION_TOKEN']);

// Create a new scheduled task
$task = $schedule->run(function () use ($courier, $dotenv) {

    echo "Running " . __FILE__ . "\n";

    // Send notification using the Courier PHP SDK
    $notification = (object) [
        "to" => [
            "email" => $dotenv['TEST_EMAIL_TO']
        ],
        "template" => $dotenv['TEST_DIRECT_SEND_NOTIFICATION_TEMPLATE_ID'],
        "routing" => [
            "method" => "single",
            "channels" => ["email"]
        ],
        "data" => [
            "name" => "John Doe",
            "place" => "123 High Street",
        "salonName" => "Cutting Edge"
        ]
    ];
    $result = $courier->sendEnhancedNotification($notification);
});

// Schedule a single notification for a specific time
$task->on('13:30 2023-07-01')
    ->description('Sending scheduled email');

return $schedule;

Now that you’ve created a scheduled task, it will run as soon as the scheduled time is reached. Remember, as mentioned above, the default timezone is UTC, but you can change this.

If you want to test your scheduled task, you can force it to run immediately using this command:

vendor/bin/crunz schedule:run --force

The above command will run all scheduled or recurring tasks that you’ve created. If you want to be sure which tasks will run with this command, you can run another command to check how many scheduled tasks you have:

vendor/bin/crunz schedule:list

This will output a table containing your scheduled tasks:

+---+------------------------------+-------------+-----------------+
| # | Task                         | Expression  | Command to Run  |
+---+------------------------------+-------------+-----------------+
| 1 | Sending scheduled email      | 30 13 1 7 * | object(Closure) |
| 2 | Sending recurring email      | 30 13 * * * | object(Closure) |
| 3 | Sending scheduled automation | 30 13 1 7 * | object(Closure) |
+---+------------------------------+-------------+-----------------+

Sending a recurring email

You can also use Crunz to create recurring tasks on a schedule.

Inside your tasks directory, create a PHP file called recurringSendTasks.php and paste this code into it:

<?php

use Crunz\Schedule;
use Courier\CourierClient;
use Dotenv\Dotenv;

// Configure environment variables - set the .env directory to the parent of the Tasks directory
// Environment variables are stored in a variable so that they can be passed to the scheduled task, which will not have access to the current global namespace
$dotenv = Dotenv::createArrayBacked(__DIR__ . "/..")->load();

// Configure scheduler
$schedule = new Schedule();

// Configure the Courier PHP SDK - note the first null is the API path, of which we will use the default
$courier = new CourierClient(null, $dotenv['COURIER_AUTHORIZATION_TOKEN']);

// Create a new scheduled task
$task = $schedule->run(function () use ($courier, $dotenv) {

    echo "Running " . __FILE__ . "\n";

    // Send notification using the Courier PHP SDK
    $notification = (object) [
        "to" => [
            "email" => $dotenv['TEST_EMAIL_TO']
        ],
        "template" => $dotenv['TEST_DIRECT_SEND_NOTIFICATION_TEMPLATE_ID'],
        "routing" => [
            "method" => "single",
            "channels" => ["email"]
        ],
        "data" => [
            "name" => "John Doe",
            "place" => "123 High Street",
            "salonName" => "Cutting Edge"
        ]
    ];
    $result = $courier->sendEnhancedNotification($notification);
});

// Set up a recurring task
$task
    ->daily()
    ->at('13:30')
    ->description('Sending recurring email');

return $schedule;

To test this, again run vendor/bin/crunz schedule:run --force. However, you’ll only receive one email, as you are using the –-force option, which forces a single run of each task. When your recurring task is being invoked by Crunz as a scheduled task, it will be called at the specified interval, and if you use the above code example, you will receive one email per day at 13:30.

Using Laravel? It’s already got scheduling baked in

If you’re using Laravel, you don’t need to worry about setting up your own scheduling solution, as it already has its own(https://laravel.com/docs/10.x/scheduling) (and queueing!) built in — one of the many advantages of using a PHP framework.

Option 2: use Courier’s automations to add send logic to your scheduled emails

Sometimes you need to add some logic around the sending of your scheduled or recurring emails, and this is where Courier’s automations can be useful. Automations allow you to chain together a series of different steps, including the sending of emails based on different notification templates.

Examples of when to use automations

Imagine a gym that sends its customers workout tips — it may want to sometimes send out different workout plans based on customers’ age or other groupings. Using automation in Courier, it could implement some basic branching logic such as “if the customer’s age is greater than 50, send an email using the over 50s email template; otherwise, send using the under 50s email template.”

Another feature that Courier automations offer is the ability to add a delay between two different actions. To reuse our hairdresser example, imagine that in addition to reminding the customer of their appointment the day before, they also want to send an email the day after their appointment to thank them and offer them 10% off their next appointment. Here’s how to implement this using Courier’s automations:

Sending two scheduled emails in one automation

As this involves sending two different emails, you will need to create a second email template for the 10% off offer. Create a new template with the following body:

Dear {name}, 

We hope you were satisfied with your hair appointment yesterday, and
we would like to offer you 10% off your next booking.

Thanks,

The {salonName} Team

Now that you have both email templates ready to go, you can create your automation in Courier. The automation sends the first email, then there is a delay (in the example below, there is a two-minute delay, but for real-world use, you would probably set it to two days), and then it sends a follow-up email. We will continue to use the PHP Crunz package to kick off the automation at the right moment (one day before the customer’s scheduled appointment), meaning that the second follow-up email will be sent one day after their appointment.

To follow along with this example, you will need to have followed the steps in the “Prepare your PHP environment” step explained earlier.

In your tasks directory in your PHP project, create a file called scheduleAutomationTasks.php and paste in the following code:

<?php

use Crunz\Schedule;
use Courier\CourierClient;
use Dotenv\Dotenv;

// Configure environment variables - set the .env directory to the parent of the Tasks directory
// Environment variables are stored in a variable so that they can be passed to the scheduled task, which will not have access to the current global namespace
$dotenv = Dotenv::createArrayBacked(__DIR__ . "/..")->load();

// Configure scheduler
$schedule = new Schedule();

// Configure the Courier PHP SDK - note the first null is the API path, of which we will use the default
$courier = new CourierClient(null, $dotenv['COURIER_AUTHORIZATION_TOKEN']);

// Create a new scheduled task
$task = $schedule->run(function () use ($courier, $dotenv) {

    echo "Running " . __FILE__ . "\n";

    // Invoke an automation using the Courier PHP SDK
    $automation = (object) [
        "steps" => [
            [
                "action" => "send",
                "recipient" => $dotenv['TEST_AUTOMATION_RECIPIENT_USER_ID'],
                "template" => $dotenv['TEST_AUTOMATION_NOTIFICATION_TEMPLATE_ID_1'], // Reminder email
                "brand" => $dotenv['YOUR_COURIER_BRAND_ID'],
                "data" => [
                      "name" => "John Doe",
                      "salonName" => "Cutting Edge"
                  ]
            ],
            [
                "action" => "delay",
                "duration" => "2 minutes" // You will probably want to delay by days or hours, but minutes are easier for testing
            ],
            [
                "action" => "send",
                "recipient" => $dotenv['TEST_AUTOMATION_RECIPIENT_USER_ID'],
                "template" => $dotenv['TEST_AUTOMATION_NOTIFICATION_TEMPLATE_ID_2'], // Follow-up email
                "brand" => $dotenv['YOUR_COURIER_BRAND_ID'],
                "data" => [
                      "name" => "John Doe",
                      "salonName" => "Cutting Edge"
                  ]
            ]
        ]
    ];
    $result = $courier->invokeAutomation($automation);
});

// Schedule the automation for a specific time
$task->on('13:30 2023-07-01')
    ->description('Sending scheduled automation');

return $schedule;

Ensure you’ve updated your .env file with any configuration you need to run this automation:

COURIER_AUTHORIZATION_TOKEN	Courier API key, found in Settings
TEST_AUTOMATION_RECIPIENT_USER_ID	Find your user ID in Courier’s list of users
TEST_AUTOMATION_NOTIFICATION_TEMPLATE_ID_1	The notification template ID for the “Hair appointment reminder” email template
TEST_AUTOMATION_NOTIFICATION_TEMPLATE_ID_2	The notification template ID for the “Hair appointment — 10% off” email template
YOUR_COURIER_BRAND_ID	Choose your brand and find its ID in its “brand settings” or URL

Now run vendor/bin/crunz schedule:run --force, and you will receive the two different emails with the specified delay in between.

Dynamic automations API documentation

To understand all the features that automations can offer, you can play around with our dynamic request builder in Courier’s [automation API documentation][20]. This allows you to build up your PHP automation request dynamically by adding request parameters. For example, if you add your preferred Courier brand ID in the “brand” box, your brand ID will be automatically added to a PHP request on the box on the right. You will need to select the “PHP” button to get a PHP request; however, other languages are available at the click of a button.

One of the key features of a Courier automation is the series of “steps” that make it up. To understand the different steps that can be part of an automation, see Courier’s extensive documentation.

Option 3: use Courier’s no-code automations designer to build complex logic around scheduled emails

The automations designer is a UI tool for building automation templates in Courier. An automation template offers a way to reuse Courier automations, and because they can be created in the Courier UI, they are super easy to create. Even your non-developer colleagues will be able to create automation templates using Courier’s simple drag-and-drop canvas.

For this example, we will use a “remember to pay your taxes” email, as this email could be sent on a schedule (April 1 of this year) or as a recurrence (April 1 every year).

Create a notification template

Create a new notification template with the subject “Tax deadline approaching,” and use the AI content generator to create some text for the body of your email. This may looks something like this:

Dear {name},

The end-of-year tax deadline is fast approaching. If you haven't yet filed your taxes, you can do this using our app:

{appUrl}

If you have any questions or concerns, please don't hesitate to contact us.

Thank you,

The {companyName} Team

Now that your template is complete, click Publish Changes.

Create an automation template

Navigate to automations, and click New Automation. Rename your automation from “Untitled Automation” to “Tax Deadline Reminder.”

To define the trigger for your automation, drag the Schedule trigger onto the canvas.

For a one-off scheduled email, change the Type of the Schedule node to Date, and enter the date and time you want your notification to be sent — in this case, we will choose midnight on April 1, 2024.

For a recurring email, change the Type to Recurrence. Then set a start date of April 1, 2024, 00:00, an end date of April 1, 2028, 00:00, and a frequency of Yearly. This will ensure the reminder email is sent for the next five years.

Next, drag a Send action onto the canvas, and ensure a line connects the bottom of the Schedule node to the top of the Send node so that it’s clear that the send action follows the schedule trigger.

Enter refs.data.user_id as the user that the email should be sent to, and select your “Tax deadline approaching” notification template from the drop-down box. Now, click on Edit next to Advanced to edit some advanced properties.

We will use the Advanced area to add some data to send to your automation template. This includes the user_id referred to in the previous paragraph plus any variables that your Tax deadline approaching notification template may be expecting.

Add this JSON to the Data section of the Advanced area:

{
  "name": "John Doe",
  "user_id": "courier-user-id",
  "appUrl": "example.com/file-taxes",
  "companyName": "Acme Ltd"
}

Finally, click Publish changes. Your email notification will be sent on April 1, 2024, at midnight.

Sending digests on a recurring schedule

If your reason for sending recurring emails is that your users are subscribed to regular news or updates from your app, you may want to set up an email digest. A digest allows you to avoid overwhelming your users with too many emails by condensing a large number of emails into one regular email update. Courier now offers the ability to send email digests. For more information, see the documentation.

Conclusion

Sending scheduled or recurring emails is not the simplest thing to do in PHP, as it doesn't have a task scheduler built into the language. On top of this, using a third party library like Crunz to deal with scheduling includes an extra layer of complication, in that you have to edit your crontabfile to hand over scheduling responsibility from your cron system to Crunz. This requires at least a basic understanding of how cron jobs work, including the syntax needed to run them.

The simpler option is to remove any need for scheduling tasks in PHP by using Courier's automation designer. This is a no-code solution that brings all your send logic inside the Courier UI. Aside from simplicity, an advantage of this is it allows your non-developer colleagues to be able to review or edit the logic around sending scheduled emails.

On the other hand, if it's more important to you to keep your send logic locked down and version controlled, and if you're prepared to get to grips with using Crunz, then you just need to decide whether you want to send a simple email (either a single email or a recurring one) — in which case you should use option 1 — or if you need to add more logic to the sending of your notifications, with the possibility of chaining together multiple steps — in which case option 2 is best.

If you haven’t yet joined Courier, you can sign up today and get started immediately. If you’re an existing Courier user, you can easily try scheduling one of your existing notification templates in our automations designer, or use our PHP SDK to get started with scheduled and recurring emails.

A Developer’s Guide to Notification APIs

Oleksii Klochai — Wed, 26 Jul 2023 13:41:04 +0000

While marketing-related notifications are often handled by marketing automation platforms, engineering teams require notification infrastructure that is designed for automated product-driven notifications. This might be a simple SMS password reset notification or new user onboarding email sequence. Or it may be a more complex notification tied to a feature of the application, such as an approval request sequence.

The infrastructure required to handle these notifications is extensive. Logic is typically required to trigger on an event, follow a specific workflow, personalize content, follow compliance guidelines, respect user preference, and work intelligently across channels (eg. email, SMS, push, in-app inbox, chat, etc). And it may require advanced send logic such as batching, digesting, throttling, and scheduling of notifications.

This is precisely what notification APIs solve. A notification API is a combination of backend infrastructure and both server- and client-side SDKs that enable developers to build notifications in web and mobile apps. It's free to signup and try Courier, the leading Notification API, yourself. Otherwise, read on to learn more.

Rather than developers spending time and effort building and maintaining the infrastructure on their own, Notification APIs give developers everything they need to create optimized, product-driven notifications that users will open and interact with.

Notification APIs are used together with communication APIs like Twilio, Messagebird, Slack, and FCS—acting as an abstraction layer to enable notification use cases. As a result, integrating notifications into an application and maintaining that infrastructure becomes a swift and future-proof process.

In this guide, we delve deeper into notification APIs, their role in transactional and marketing notifications, practical use cases, and the indirect benefits they offer.

Understanding and using notification APIs

Here are some examples of Notification API features. These are capabilities that add notification capabilities to communication APIs such as Twilio, Microsoft Teams, MessageBird, Slack, and so on.

Multi-channel send: Notification APIs allow for dispatching notifications across multiple channels, like email, SMS, and push notifications. This frees developers from the complexities of maintaining individual infrastructures for each channel, streamlining the process considerably. For instance, an HR application might dispatch a job offer requiring a signature via SMS, a channel offering urgency and external reach, while using a tool like Slack—an internal, less urgent channel—for onboarding tasks with a new employee.

Delivery status awareness across channels: A unique feature of notification APIs is their ability to track delivery status across all channels. This means, if an email, SMS, or push notification has been successfully delivered, it's accurately logged and reported. This insight enables developers to understand the efficacy of their communication across different platforms.

Additionally, some sophisticated notification APIs also monitor “read statuses.” This means that when a user reads a notification on one platform, it can potentially halt the delivery or alter the display of notifications on other channels, for example marking them as opened or read.

Automations: From fetching the latest data for inclusion in a notification to setting up advanced delivery timings and rules across channels, notification APIs automate much of the orchestration process. Automations within notification APIs reduce manual effort and potential errors. This might involve sending a time-delayed, multi-channel sequence of notifications that stop as soon as the user reads them. Alternatively, it could involve digesting and batching frequent notifications based on preset or user-defined frequency or even throttling messages that trigger too often.

Template management: Many notification APIs offer tools for developers to efficiently design, manage, and repurpose notification templates across various channels. These include pre-made templates as well as the option to create your own, eliminating the necessity of crafting notifications from scratch every time. This allows developers to focus more on the message and its intended impact, enhancing efficiency and overall user engagement.

Central logs and reporting: Robust logging and reporting capabilities are integral to notification APIs. This is especially relevant for notifications because it can present delivery status across channels in a single view. These features provide invaluable insights and aid in troubleshooting.

User preferences: Notification APIs provide a simple way to collect and respect user preferences for notification topics, channels, and frequencies, ensuring notifications don’t overwhelm users. Eg. a user might want to receive billing notifications via both SMS and email. But they may want to receive system error notifications via PagerDuty. And they may want to hold all comments on a project, to be rolled up into a single email digest every week. All of this is possible with a Notification API, which provides both the frontend components for the UI as well as the backend logic to respect these preferences. If all notifications get sent through a notification API, the service becomes a useful tool for controlling users’ notification preferences.

Web and mobile notification center (Inbox): In addition to external channels like email, Slack, and SMS, it often makes sense to hava a notification center, or "inbox" that lives inside of the web or mobile app. This typically also includes a bell icon with a change badge that counts number of messages, as well as related push notifications. A notification API will not only handle all the back-end logic for this functionality, but it will typically also offer a complete set of web and mobile SDKs for building the frontend experience. This allows developers to construct a fully functional in-app inbox and preference center with a notification API, elevating the overall user experience with minimal additional development time. Here's an example of Courier's inbox offering.

Internationalization: Notification APIs offer the advantage of internationalization. If the API manages message templates, it’s possible to select a template appropriate for each user’s region and language or even work in sync with a translation API to serve translated versions of notification content. This ensures that each user receives personalized and localized notifications, further improving user engagement and satisfaction.

By leveraging a notification API, a developer can save time on building these features without sacrificing the end users’ experience or creating technical debt.

The role of notification APIs in transactional versus marketing notifications

Notification APIs are typically used for transactional notifications. However, the transition away from moment-in-time marketing campaigns to ongoing Growth loops, is making Notification APIs more appropriate for marketing notifications than traditional marketing automation tools. To understand why that’s the case, let’s quickly define these two notification categories.

Transactional notifications are often triggered by user actions, such as making a purchase, resetting a password, or receiving a direct message. Or they may be tied to the functionality of a product feature - like a commenting feature in the app where you want to notify a person of an @mention. As their name suggests, these notifications are tied to specific transactions or interactions a user has with the application, playing a continuous role in user experience. They might rely on external channels like email and SMS or, for SaaS apps, they may be used with internal channels such as Slack, MS Teams, and PagerDuty.

Notification APIs prove particularly useful for transactional notifications due to their dynamic and event-triggered nature. By leveraging APIs, these real-time, personalized messages can be handled as they are generated, ensuring relevance.

On the other hand, marketing notifications are traditionally associated with promotional time-bound campaigns for a product, offer, or service. These messages focus on driving conversions or sales. Unlike transactional notifications, marketing notifications usually aren’t specific to the user or their activity in the app but instead get sent to larger groups of users. Marketing notifications also focus on external channels like email, SMS, push, and in-app.

Marketing notifications have traditionally been managed through a marketing platform due to their mass distribution nature and the connection to marketing campaigns. Specialized marketing platforms typically address the need for features such as opt-in logic to comply with anti-spam regulations, campaign management, and detailed analytics of the conversion process.

However, product growth experiments now cross the divide of marketing and are often more appropriate for Notification APIs than marketing automation tools. For example, if a user hits a key usage lifecycle milestone in your application, you may want to trigger a notification with a unique offer or with best practices to ensure their success. These kinds of notifications can drive higher application engagement and overall monetization of the app.

Over time, notification APIs have the potential to bridge the gap between transactional and marketing notifications. This potential stems from notification APIs’ ability to offer more personalized, event-driven marketing notifications that adhere to the user’s behavior and preferences.

In essence, notification APIs offer a robust framework that supports both transactional and marketing notifications, creating a cohesive and engaging user experience.

Benefits of using a notification API for developers

Notification APIs offer numerous indirect benefits that enhance efficiency, increase flexibility, and improve the developer experience.

One key advantage of notification APIs is provider independence. APIs abstract the underlying implementation details, allowing developers to switch providers (eg. from Postmark to SenGrid) swiftly if necessary without disrupting the overall application function. They can even provide failover between channels and providers without having to build out complex logic.

Notification APIs also offer consistency in notification formatting and delivery across various channels. Consistency improves user experience by ensuring each message is uniform, regardless of the channel through which it is sent.

From a developer’s perspective, APIs simplify the integration and management of notification systems. Developers don’t need to write boilerplate code for every new channel or message type or worry if their abstractions will carry over into a new provider’s API schema. Instead, they leverage the API’s functionality and use whichever providers they need, which can save considerable time and effort.

Sample use cases for notification APIs

Here are some examples of what you could build in your product using a notification API:

Status updates: Inform users about the progression of their initiated actions, such as “Your order is out for delivery” in a food delivery app context.
Appointment reminders: Remind users about upcoming appointments, deadlines, or important dates.
Approval requests: Request user approval for specific actions, such as document sharing or data access.
Authentication management: Handle password resets or two-factor authentication prompts.
Confirmation requests: Ask users to confirm potentially irreversible actions or decisions, such as deleting data.
Billing notifications: Inform users about upcoming payments, send payment confirmations, or notify them of billing issues.
Automated invites: Send automated invitations to events or cooperative endeavors.
Digests: Provide digests or summaries on user-selected topics at a frequency and channel set by the user.
E-commerce: Handle cart abandonment notifications, shipping updates, or requests for credit card updates.
Product engagement: Prompt users to return and complete a task, enhancing user engagement.
Survey requests: Solicit user feedback through surveys or review requests.
Welcome and user onboarding messages: Help new users get started with welcome messages and onboarding instructions.
Notify about a user’s activity: Alert users about new logins or changes to a shared project.
Platform engagement: Encourage users to engage with a platform or service more frequently.
Critical alerts: Notify users about critical issues, such as security alerts, product downtime, or other urgent matters.

In each of these use cases, notification APIs streamline the process of sending timely, relevant, and personalized notifications to users, enhancing user engagement and satisfaction.

Conclusion

Notification APIs have emerged as tools that enable developers to build product notification experiences that users love. By offering a streamlined way to manage notification content, delivery logic, internationalization, compliance, and user preferences, notification APIs reduce the complexity of building and maintaining the underlying infrastructure.

Notification APIs also help improve the user experience. By running all notifications through a single service, it’s possible to offer users more flexible preferences and cross-channel syncing of notification statuses. Prior to Notification APIs, only the largest, most sophisticated engineering teams could build this level of infrastructure in-house.

If you are interested in using a notification API, Courier is considered the leader in the market, funded by Twilio, Slack, and Google and used by companies such as Comcast, LaunchDarkly, Contentful, and Lattice. Courier is free to use for up to 10,000 notifications per month.

Courier Inbox for web and mobile, a complete notification center

Micah Zayner — Wed, 14 Jun 2023 07:42:59 +0000

📣 Join the conversation on Product Hunt where we're discussing this groundbreaking launch and the future of in-app notifications.

A notification center inside of web and mobile apps is now an expectation. It’s a way to reach specific audiences or users with tailored messages and a way to boost engagement by bringing people back into the app.

While Courier has been adding Inbox capabilities over the last couple years, we’re excited to announce a complete set of SDKs that span web and mobile. You can drop in a full-featured inbox to give your users a best-in-class notification center inside your app that works seamlessly with your existing notification flows.

Here are just a few features of Courier Inbox:

All the code needed to build custom notification lists that show new messages when they arrive in real time.
Prebuilt-UI that allows you to add a notification center to your app in minutes rather than months.
API, event or manually triggered notifications to your user’s inbox, or using inbox as one step in a multichannel sequence that includes email, Slack, or any channel.
Synchronization of message status across web and mobile inboxes, as well as other channels used like email and SMS.
User notification preferences to offer more control to your users over what notifications they receive from your app and which channels work best for them.

To see the full set of features for Courier Inbox, head to the docs. Or, if you’d like to see an example of what you can build with Courier, check out our Instagram-inspired IOS app, Puppygram or see how inbox is used at LaunchDarkly, DroneDeploy, and Oyster HR.

Options to build with Courier Inbox

Previously, it was only feasible for large engineering teams to pull off a full-fledged notification inbox. Smaller teams often found themselves strained by the sheer scope of the project. Besides the engineering challenges, the design and user interface for the notification inbox also required thoughtful attention. Even though standard patterns exist in popular apps, like Instagram and Amazon, there's pressure to deliver a user-friendly experience that’s on-brand and doesn’t compromise the aesthetic integrity of the overall application.

This was an important driver for Courier Inbox. We wanted to make sure we offered complete SDKs for web, Android and IOS, where a developer has access to the development tools and UI components so that the frontend is as well designed as the backend. Courier also offers customizable branding design options, to match your inbox to your application's look and feel.

Whether you're looking for a fully hosted implementation that requires minimal configuration or a composable, headless offering that you can tailor to your specific needs, Courier has got you covered.

Real-world examples

DroneDeploy

As a leader in drone mapping software, DroneDeploy offers services that capture interior and exterior visual data of a construction project or other environment, managing drone fleets for site documentation and analysis.

With Courier, we added a beautiful inbox and in-app push notifications in a matter of weeks. We used the great looking pre-built component to save even more time. Notifications are not our core competency, so it made complete sense to integrate rather than build out and support our own implementation.

James Pipe, VP of Product, DroneDeploy

DroneDeploy has integrated Courier's inbox into their web application as a notification center. This has significantly improved customer communications, providing timely updates and important information to clients directly within the app.

Top notifications sent through their inbox include status updates when new maps, walkthroughs, or progress videos are uploaded, and edit access is requested/approved/declined.

LaunchDarkly

LaunchDarkly offers a feature management platform to developers and DevOps engineers. The platform offers multivariate feature flags, which enables A/B testing and the ability to incrementally roll out new features.

We were able to build the in-app notification experience that we wanted with excellent support and communication from the Courier staff.

Lucy Wonsower, Software Engineer, LaunchDarkly

LaunchDarkly uses Courier's inbox for:

Managing event notifications for their feature management platform, such as requests for a new feature flag, or approvals of a feature flag request. The notification inbox speeds up these requests and approvals, thereby increasing value and customer retention.
Sending team notifications such as team membership admin alerts, new user invites, welcome emails, and email verification messages.
Billing notifications such as notifications that a user’s card was charged or that there was a failure to charge a card.

Oyster HR

Another organization that has reaped significant benefits from Courier's notification inbox is Oyster HR. As a global employment platform, Oyster HR enables businesses to hire, pay, and manage employees from across the world without the need to set up business entities in each country.

Using Courier Inbox, Oyster saved 4 engineers 3 months of work from not having to construct a notification infrastructure, design a UI, and develop them to spec. But the most important benefit is that as Oyster scales, we won't need to hire additional engineers solely to manage our notification framework as the volume grows.

Amy Weinrieb, Senior Product Manager, Oyster HR

Integrating Courier's notification inbox

One of the standout features of Courier's notification inbox is its simplicity of integration. Whether it's a mobile or a web application, a few lines of code are all you need to embed a fully functional notification inbox into your application.

Here we have examples for adding an inbox to your web, IOS, and Android applications.

Adding a notification center to your web application

For web applications, you can use either the Courier React SDK or the vanilla JavaScript SDK. Here is a simple React example to illustrate this process.

//App.js
import { CourierProvider } from "@trycourier/react-provider";
import { Inbox } from "@trycourier/react-inbox";

function App() {
  // Replace 'yourUserId' and 'YOUR_CLIENT_KEY' with your own details
  const userId = 'yourUserId';
  const clientKey = 'YOUR_CLIENT_KEY';

  return (
    <CourierProvider userId={userId} clientKey={clientKey}>
      <Inbox />
    </CourierProvider>
  );
}

The above code is all it takes to integrate Courier's notification inbox into your React application. You just need to import CourierProvider and Inbox from @trycourier/react-provider and @trycourier/react-inbox respectively. Then, you set the userId and clientKey within the CourierProvider, and place the Inbox component within it. Look at the README on GitHub if you need more information.

The userId and clientKey are crucial for Courier to know who's using the inbox and to ensure the proper messages are displayed. The clientKey is a public-facing key that can be found by navigating to "Settings > API keys" in the Courier app.

The snippet uses the basic authentication provided by Courier. However, for enhanced security, it is recommended to use JWT Authentication. The complete guide to set up JWT Authentication can be found here.

Adding a notification center to your IOS application

Here is an example for an iOS application written in Swift:

import Courier_iOS

// Create the view
let courierInbox = CourierInbox(
    didClickInboxMessageAtIndex: { message, index in
        message.isRead ? message.markAsRead() : message.markAsUnread() 
        print(index, message)
    },
    didClickInboxActionForMessageAtIndex: { action, message, index in
        print(action, message, index)
    },
    didScrollInbox: { scrollView in
        print(scrollView.contentOffset.y)
    }
)

// Add the view to your UI
courierInbox.translatesAutoresizingMaskIntoConstraints = false
view.addSubview(courierInbox)

// Constrain the view how you'd like
NSLayoutConstraint.activate([
    courierInbox.topAnchor.constraint(equalTo: view.topAnchor),
    courierInbox.bottomAnchor.constraint(equalTo: view.bottomAnchor),
    courierInbox.leadingAnchor.constraint(equalTo: view.leadingAnchor),
    courierInbox.trailingAnchor.constraint(equalTo: view.trailingAnchor),
])

Task {
    try await Courier.shared.signIn(
        accessToken: "pk_prod_H12...",
        clientKey: "YWQxN...",
        userId: "example_user_id"
    )
}

This approach exemplifies the ”drop-in” method. You begin by importing the Courier_iOS package, add the view to your app, then sign in to your Courier account using your access token, client key, and user ID. The CourierInbox, for UIKit, and the CourierInboxView for SwiftUI, is then placed in your app how you’d like and, instantly embedding the notification inbox into your application with minimal effort. It's a quick and efficient way to get started, allowing developers to focus on building the core aspects of their app. This way, you can offer a powerful notification inbox to your users without spending significant time on implementation — and, more importantly, without compromising on the feature set.

Adding a notification center to your Android application

For those interested in Android, here is the default inbox example for you.

val inbox: CourierInbox = view.findViewById(R.id.courierInbox)

inbox.setOnClickMessageListener { message, index ->
    if (message.isRead) message.markAsRead() else message.markAsUnread()
    Courier.log(message.toString())
}

inbox.setOnClickActionListener { action, message, index ->
    Courier.log(action.toString())
}

lifecycleScope.launch {
    Courier.shared.signIn(
        accessToken = "pk_prod_H12...",
        clientKey = "YWQxN...",
        userId = "example_user_id"
    )
}

This code snippet showcases the power of the Courier library in Android development, demonstrating the ability to log, mark messages as read or unread, and capture actions.

Alternative, headless approach to building an inbox with Courier

But what if you need more control over your notification inbox's appearance and behavior? Courier also offers a headless option. This approach allows developers to customize every aspect of their inbox, tailoring it to meet specific design or functional requirements. You have the flexibility to change everything from the overall layout and individual components to the styling of each notification card. This way, Courier ensures that developers can create an inbox that not only fits their needs but also aligns perfectly with their application's UI and UX.

Next steps

Whether you’re working on web or mobile app development, Courier provides a comprehensive, flexible, and easily integrable solution to ensure your users are always in the know and keep coming back to your app.

It’s free to try. You can send 10,000 messages every month for no cost as you get to know the ins and outs of what’s possible with Inbox. To help you get started, we suggest exploring the detailed guides for each platform: iOS, Android, and web. These comprehensive guides provide step-by-step instructions and code examples to guide you through the integration process.

Don't forget, Courier also provides seamless integration with push notifications. We've previously covered how to set up push notifications with Courier. By combining these two powerful features, you can provide a complete, personalized notification experience to your users.

Remember, providing a top-notch notification experience to your users doesn't have to be a daunting task. If you want to build a custom notification inbox that is not only user-friendly and efficient but also easily integrable across platforms, start your notifications journey with Courier today!

How to Create an Automated SMS Notification System

Charla Bigelow — Tue, 18 Apr 2023 06:40:00 +0000

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:



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 based on your preference.

** Step 1: Sign up for Twilio**

** Step 2: Set up your preferred SMS API in 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, an Auth Token, and a Messaging Service SID, 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.

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.

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.

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.

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.

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

Create an Automation

Step 1: Create a new Automation

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:

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

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 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.

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.

New Datadog integration for Courier notification logs and metrics

Charla Bigelow — Wed, 12 Apr 2023 16:00:00 +0000

The ability to unify all notification metrics and logs across channels and providers into an easy-to-use dashboard is a core advantage of Courier’s notification infrastructure.

However, with product notifications so critical to the entire application experience, it’s important to connect that data back to central cloud observability platforms that look across the entire stack. This gives platform engineering teams a complete understanding of application health and lets them quickly troubleshoot even the most complex issues.

Today, we’re incredibly excited to announce our first observability integration with Datadog.

Datadog is a tool for collecting metrics and other data from applications and viewing them in a centralized place. Datadog’s dashboards and monitoring tools build a more accurate picture of the health of your application and how it changes over time.

Our integration with Datadog is easy to spin up when you use our “dashboard starter kit.” This consists of some pre-configured JSON to set up a simple dashboard in Datadog for your Courier data.

Our Datadog integration is currently only available on Courier’s Business plan, much like our other production-focused features such as template analytics, Okta integration for SSO, and advanced user preferences.

The fastest way to pull your notification data into Datadog

Courier's message logs and analytics dashboard are optimized for helping product teams understand everything about the messaging use case — the status of notifications, recipients, lists, automations, and more. It brings all this data together across channels and providers in one place and provides the fastest way to learn about your notifications and troubleshoot notifications-related issues.

However, many organizations need to understand how notifications interact with the rest of the tech stack or would prefer to view and store all logs and metrics data in one place.

Until now, the only way to pull this data outside of Courier was to build your own bespoke solution, by listening to Courier’s outbound webhooks and writing custom code. But now the Datadog integration enables sending information about health and performance directly to your own monitoring system, which is much more convenient.

Use cases

Notification metrics and logs

The most obvious use cases involve sending data about the health and delivery status of your notifications. This could include metrics such as:

Percentage of messages that are successfully sent, delivered, opened, and clicked.
Delivery errors
Percentage of customers who are unsubscribing from your messages
Any metrics that measure outliers — for example, a metric that checks if you are sending either more or fewer messages than you should be.
Number of people who opened your emails over time.

(An example Datadog dashboard showing key notification health metrics)

(A Datadog graph showing the number of emails that are being sent over the course of the day — as well as how many emails are being opened and how many people are clicking on email links. There are options to compare these metrics to other time periods such as the previous day, week, or quarter.)

Feature-specific metrics and logs

The integration also supports data from Courier platform features. This can provide even more color on how notifications support your business or operational goals. For example, If you use Courier Automations to build smart notification workflows, you may want to monitor how many times each automation has been invoked. Or, if you use Courier’s in-app notification Inbox, you might choose to monitor the number of connections to your Inbox and compare this to the number of active users on your site. A significant difference could indicate a problem that needs further investigation.For example, you might have released a change that broke your Inbox implementation through changes to an authentication method or a key.

What data can be sent to Datadog from Courier?

Metrics

Courier metric names will have a courier.* prefix — for example, courier.notification.sent. A full list of all the Courier metrics that are available for you to send to Datadog is provided here. These metrics will be sent with additional information, such as success or failure codes, and tags (including whether the metric is for your production or staging environment).

Once the metrics are being sent to Datadog, you can set up corresponding alerts in Datadog. For example, you could set up an alert that emails your engineers when the number of notification delivery errors reach a certain predefined threshold.

Logs

Courier always had the ability to record logs about notifications, recipients, lists, and automations. Now these can be sent to Datadog in the same way that metrics are sent.

Courier’s logs provide details about delivery failures, as well as other information that can be relevant when debugging. With these logs now in Datadog, you’ll now be able to easily correlate the logs to your metrics, helping you debug any issues.

Setting up the Datadog integration

To set up this integration all you need is your Datadog API key and URL. From there, simply follow the setup guide, which will cover the steps to connect Courier with Datadog and how to create a Courier-specific dashboard in Datadog. This is where you’ll find our “dashboard starter kit,” a JSON file that has everything you need to set up a Courier dashboard, including commonly used Courier metrics. You can easily customize the JSON to add or remove different metrics according to your needs.

Next steps

If you’re already on Courier’s Business plan, you can start sending metrics and logs to Datadog right away. Otherwise, you can request a demo, and we’ll walk you through this integration in more detail, along with the other features in the Business plan to see if it’s right for your use case.

The ability to access your metrics and logs in an observability platform like Datadog allows you to set up a dashboard that shows the data that’s most important to you. You can also create graphs that enable you to see at a glance if something’s not right, or even set up alerts based on message delivery failures. Whatever size your business is, some level of monitoring is necessary if you want to have control over your application.

If you’re a Datadog user who is interested in trying Courier’s full-featured notifications infrastructure, you can try it for free.

Streamline your workflow with CourierJS: Our new client-side SDK

Charla Bigelow — Mon, 10 Apr 2023 16:03:00 +0000

We are thrilled to announce the release of our first client-side SDK for Courier, written for JavaScript. This new addition expands our existing SDK offerings, which include Java, Python, Node, Go, Ruby, and PHP, and makes it even easier for developers to integrate Courier into their projects. By enabling direct calls to Courier within your JavaScript code, you can eliminate the need to use a back-end service as an extra layer between your front end and the Courier API, saving valuable time and resources.

With the initial release, we're introducing three new API calls: the identify call for tying a user to actions they perform, such as logging in or updating their profile, and the subscribe and unsubscribe calls for subscribing and unsubscribing to lists. By simplifying these key interactions, CourierJS enhances the overall experience of using Courier.

Client-side vs. Server-side SDKs

You may still be wondering: why introduce a client-side JavaScript SDK for Courier when we already have SDKs for many other languages? Let's dive into the differences between client-side and server-side SDKs, which will help you determine the right type of SDK for your specific needs.

(Comparing integration flows: with and without Courier client-side SDK)

Client-side SDKs are designed to provide a way for you to interact with an API within your application's front-end code. Server-side SDKs, in contrast, interact with your back-end code, making them more suitable for processing and handling data that doesn't directly involve user interactions on the front end. By offering a client-side JavaScript SDK, we're providing developers with an alternative to server-side SDKs that is more suitable when you need to integrate Courier's functionality directly into your web application's front end. When trying to call the API from your front end, having an extra layer of back-end code might not always be the most suitable option for certain use cases. With CourierJS, we provide an alternative that streamlines the process and caters to a broader range of scenarios, enhancing efficiency and helping you deliver valuable applications more quickly.

We have taken inspiration from popular customer data platforms like Segment and RudderStack, both of which provide an identify call. In addition to an identify call, which ties a user action to a particular user, our initial release also includes support for subscribing and unsubscribing to lists, allowing users to manage their communication preferences with ease.

The JavaScript SDK has been designed to be both intuitive and efficient, working exactly how you'd expect. Instead of issuing multiple commands to update specific fields, you can now easily update multiple fields in a single operation. For example, if you have a user with an ID, name, email address, physical address, and phone number, and you just want to update the email address and phone number, you can pass in just those values. The SDK also automatically merges new data with pre-existing data, overwriting only the specified fields. This functionality ensures a smooth integration with your front-end code and a more seamless user experience.

Discover the advantages of CourierJS

Previously, developers using Courier only had access to server-side SDKs. These SDKs required the front-end code to communicate with the back-end services to utilize Courier's functionality, often adding an unnecessary extra layer. In some cases, you even had to create an entire back-end service just to handle the Courier SDK.

One of the primary challenges faced when using server-side SDKs in the context of Courier arises when you need to send data from the front end to Courier, which previously required going through the back end. This process can be manageable, but it can also be tedious for developers who want a more streamlined solution. To address this, we’ve developed the client-side SDK, making it easier for those who want to directly integrate Courier's functionality into their web application's front end, bypassing the need to pass data through the back end first.

By introducing the new Courier client-side SDK, we aim to simplify this process and reduce the workload for engineers. This not only saves time but also accelerates the implementation of new features, making your development process more efficient and agile.

Ready to get started? Using CourierJS is a breeze

Now that you've discovered the advantages of the Courier client-side SDK, it's time to dive into how you can seamlessly integrate it into your project. To begin, all you need to do is install the JavaScript package and start using the provided function calls in your code. For a comprehensive step-by-step guide on setting up the Courier client-side SDK, you can refer to our documentation here.

Exploring the new API calls in Courier's client-side SDK

Now that you're all set up, let's take a closer look at the new API calls introduced in the SDK.

The `identify` call

The identify call allows you to create and update user profiles with ease. Here's an example of how the identify call can be used in your code:

await courierSDK.identify("user123", {
  email: "user123@example.com",
  firstName: "John",
  lastName: "Doe",
});

In this example, the identify call creates or updates a user profile with the specified user ID, email, first name, and last name. The simplicity of the call ensures that you can quickly and easily update user profiles as needed, making it an invaluable tool in your communication management toolkit.

Subscribing and unsubscribing from lists

A list in Courier is a way to group recipient profiles, allowing you to send a message to all subscribed recipients with a single call. This feature is particularly useful for managing newsletters, product updates, and other types of mass communication.

Managing user subscriptions is easy with the new subscribe and unsubscribe API calls. These calls make it straightforward to maintain up-to-date lists of subscribers, due to not needing to call a back-end service. Here are examples of how to use the subscribe and unsubscribe calls in your code:

// Subscribe a user to a list
await courierSDK.subscribe("user123", "my-newsletter-list");

// Unsubscribe a user from a list
await courierSDK.unsubscribe("user123", "my-newsletter-list");

As you can see from the comments in these examples, the subscribe call adds a user to a specified list, while the unsubscribe call removes them from the list.

By incorporating these new API calls into your project, you can further streamline your development process.

Conclusion

Throughout this article, we've unveiled the power of the new CourierJS client-side SDK and explored its features, including the identify call and subscribe and unsubscribe calls. By using the CourierJS client-side SDK, you can reduce the workload involved in your development process and improve the overall efficiency of your projects.

As you’ve seen, the SDK saves you time and effort by eliminating the need for complex back-end services and enabling direct communication between the front end and Courier. Its intuitive functionality, ease of use, and powerful capabilities make it a valuable addition to your development toolkit.

We encourage you to try out the new CourierJS client-side SDK and experience the benefits it offers firsthand. By adopting this innovative tool, you can enhance your product-triggered communication management and unlock the full potential of the Courier ecosystem.

Introducing the new and improved Automations designer

Charla Bigelow — Mon, 03 Apr 2023 15:31:00 +0000

Courier Automations lets you build smart notification workflows. With Automations, notifications can be scheduled, driven by events, canceled, and more.

We’ve just completed a big redesign of the automations UI — before this overhaul, notifications were restricted to linear workflows. This made it difficult to build more advanced automations, however the new automations UI, based on React Flow, allows you to build more sophisticated workflows, including those requiring branching logic.

In this article, we explain the differences in functionality between the old and new UI, how the new UI helps developers as well as product managers, and how the migration will affect you if you’re already using the automations designer. For those who are new to Courier automations, we explain the background of what automations are for and how to use them. We also cover how to use the new UI, while providing some useful real-world examples to help you get started.

What is Courier?

Courier serves as a product-oriented notification platform, and is well-suited for the post-marketing phase of a business; allowing you to streamline communication with users across your websites and/or applications. Its unified API accommodates multi-channel delivery — including email, SMS, browser notifications, push notifications, and direct messages through platforms such as Slack or Microsoft Teams. The power of the Courier app is that it allows you to design versatile message templates that can be easily repurposed across each messaging channel.

You can pull data from other systems into Courier, to populate variables within your message templates or when building your application logic in your automations. This data can come from a variety of sources — for example, from customer data platforms (CDPs) like Segment or RudderStack, or from your own site.

What are Courier automations?

Courier automations enable you to craft intricate notification delivery workflows while seamlessly integrating your custom application logic into the Courier notification ecosystem. Automations can be controlled either through an API or through the automations designer inside the Courier app. The automations designer allows you to design automations either by using a visual builder or by directly editing JSON. It’s the fastest way to build workflows.

The latest update to the automations designer includes a big update to the visual builder. Where previously your workflows were limited, or were made unnecessarily complex by the linear nature of the visual builder, you can now use the designer to design complex workflows in a simple and intuitive way.

For example, if you want to send different welcome emails to different groups of people based on user attributes, it was difficult to handle this level of complexity in the old UI.

(The old UI consists of a linear series of steps. In this example, a Segment event, “Account Created” triggers a 10-minute delay before sending a welcome email.)

(The new automations designer has drag-and-drop elements that can help you create non-linear workflows. In this example, the Segment event, “Account Created” triggers a 10-minute delay and then checks whether the user’s job role contains “engineer.” If they are an engineer, they will be sent the engineer-specific welcome email, and if not, they will receive a generic welcome email.)

The new automations designer was built using React Flow, a library for building node-based interactive UIs. You can build your messaging workflows by dragging and dropping different elements such as triggers and actions onto a canvas. You can then connect them together in a sequential order, or use branching logic if required to build a more complex workflow.

The example above shows a workflow for waiting until a user has signed up to send them a message. If they’re online, you can just send a browser notification; otherwise you might want to send an email.

The elements of a Courier automation

Triggers

Triggers are events that cause a new automation run to be started. They define the conditions that must occur before an action can happen. A simple example of a trigger is a scheduler that waits until a particular timestamp is reached before an action can happen (such as sending a notification). Data pulled from your CDP can act as a trigger, too — for example, a new user signing up to your system.

You can also make use of data from Courier Audiences to design your triggers. An Audience is a dynamic list of your users. When someone joins or leaves an Audience, this event could be used as a trigger to send a notification. An example of this could involve an Audience of all users who are software engineers. If a user who previously worked in tech support becomes a software engineer, as soon as they update their profile they become part of the “software engineer” audience — which will cause your trigger to invoke an action such as sending a message.

Actions

An action is an activity that happens following a trigger. The most common action in Courier is the sending of a message, either to an individual or group. However, actions can also include fetching data from another API, updating a user profile, or adding a delay to your workflow – for example, waiting for 24 hours after a user signed up to remind them to fill in their profile.

Branching logic

Branching logic is a new feature in the latest automations designer that allows you to design more complex workflows by dragging and dropping if statement blocks into your workflow. These are accessed in the menu on the left, under “Control Flow.” An if statement block has nodes next to its true and false conditions, so you can draw lines that link these different conditions to the next steps in your workflow. As this doesn’t involve writing code, non-developers with a decent understanding of the data involved are often able to design their own notification workflows.

(Once you’ve dragged an if statement box onto the canvas, you can connect it to different parts of your workflow by drawing lines from the true or false nodes to other elements within your automations template.)

Why the new version of the Courier automations designer helps you

Until now, if you were using automations for complex, non-linear workflows, there was a good chance you had to manage this logic yourself using our API, which may even have required a separate back-end service just for dealing with this. And, due to ever-changing requirements, you may have needed to regularly update your code in small but necessary ways.

This can now be done in the UI, leading to much faster turnaround for small workflow changes. To achieve the fastest turnaround, it’s worth empowering product managers or designers to make their own changes to the logic when needed, so they don’t have to wait for a developer to fit small changes around feature work. As long as they have some knowledge of the underlying data, this can be accomplished with minimal training, as the interface is very intuitive. Allowing your colleagues to create or edit automations has the added benefit of freeing up your time to do more feature work instead of having to focus on small updates to application logic.

How to use the automations designer

You can follow our documentation on how to create a basic automation using the new automations designer UI. After creating your automation template, you’ll need to publish it before it can be invoked. The standard way for an automation to be invoked is automatically — when its trigger condition is met. However, it is still possible to invoke an automation by using our automations API.

If you need to use variables within your automations — for example, if you want to send your message to varying recipients, or if you want your message template to vary according to certain conditions — you can use our refs variable, which stores dynamic data within Courier.

The automations API

If you prefer to use the API directly, or use an SDK, that’s still an option. You can use these to either invoke automations or get the status of automations. For existing users of the API, you can be reassured that we’ve made no changes to the API — our latest automations release applies to the UI only.

Details for existing users of the automations designer

For existing users of the automations designer, we’ll now cover the main points that are likely to be of interest: the main differences between the old and new UIs, and what you need to do to migrate to the new version of automations.

Differences between the old and new automations designer UIs

The main difference is that the new automations designer UI is more expansive: you are no longer forced to follow a linear workflow, and can take advantage of branching logic. In addition to this, we have added some improvements to make the UI easier to use. For example, running an automation on a repeat schedule used to require users to learn Cron expressions — something that even most engineers have a tough time remembering. Now, with the new “Schedule” trigger, scheduling an automation is as easy as scheduling an appointment in your favorite Calendar app. Changes like these have made the UI more user-friendly, meaning that letting non-developers set up their own workflows is finally an option.

What you need to do to migrate to the new version of automations

You don’t need to do anything! We have already rolled out the new changes, so no work is required from your end.

If you have any existing automations templates that you’ve designed in the past, these will not change. They will appear in exactly the same way using the old UI. However, any new automations templates that you create will now appear using the new UI.

Get started

You can get started creating automations with the new Designer directly in the Courier UI. Setting up smart notifications in the new UI is fast and intuitive — just follow our documentation.

Simplifying notifications with the Courier iOS SDK

Charla Bigelow — Thu, 23 Mar 2023 17:16:58 +0000

Push notifications are a valuable tool for keeping users informed and increasing their engagement with your app. You can use push notifications to alert users about promotions, new content, or any other important updates. While push notifications are a powerful tool, setting up push notifications in iOS can be a daunting task that requires a significant amount of effort and time. Fortunately, the Courier iOS Mobile Notifications Software Development Kit (SDK) simplifies this process.

The Courier iOS SDK can help you to implement push notifications in iOS apps more easily thanks to some useful tools. The benefits of using the SDK include:

Simplified setup process. The Courier iOS SDK streamlines the process, making it easy to get set up and start sending push notifications. With some easy-to-follow setup steps and a few lines of code, you can quickly integrate the SDK into your apps.
Effective management of tokens and user state. When implementing push notifications, you would normally need to handle token management manually, which involves generating and storing unique identifiers for each device that can receive notifications. This can be complex and time-consuming. The Courier iOS SDK provides tools that enable you to manage tokens and user state effectively.
Sending test notifications. Before sending push notifications to all users, it's important to test that they're working as intended. With the Courier iOS SDK, you can send test notifications to check that your notifications are working as intended before they go live. This can save time and prevent problems later.

Token management

Managing push notification tokens is a complex task. Let’s talk a bit about how they work, to help us better understand the benefits of the Courier SDK.

Tokens are unique identifiers that are used to identify a specific device for push notifications. They are generated and managed by the push notification service, which is the Apple Push Notification Service (APNS) for iOS. These tokens need to be securely stored on the back end, associated with the relevant user or device, and regularly updated as they can change or expire. Additionally, token management includes handling token deletion when a user unsubscribes from push notifications or uninstalls your app.

Setting up and managing your own token management infrastructure can be a time-consuming and challenging task, requiring collaboration between front-end, mobile, and back-end developers. However, with the Courier iOS SDK, token management is handled automatically. The SDK automatically takes push notification tokens, stores them in Courier, and invalidates tokens that expire, so you can focus on building your product without having to learn the complex logistics of token management.

Getting started with Courier's iOS SDK

Before you can use the Courier iOS SDK, you'll need a few things:

Xcode. You'll need to have Apple's integrated development environment (IDE), Xcode, installed on your computer.
An Apple developer account. To enable push notifications in your app, you'll need a valid Apple developer account.
A physical iOS device. You'll need an iOS device to test your push notifications.

You can find a full and detailed set-up guide in the iOS docs on the Courier GitHub repository.

Push providers

Before we look at sending a test push notification, it’s worth noting that to enable push notification support you will need to configure a push provider. A push provider is a service that handles the delivery of push notifications to targeted devices, ensuring reliable and efficient message transmission.

Take a look at our GitHub page for more information. There you will find links to APNS (Apple Push Notification Service) and FCM (Firebase Cloud Messaging). Follow the links there to see more detailed information.

Enabling push notification capability

Another vital step is to enable push notification capability in your iOS app. Here's how to do that.

Create a new iOS app ID and a provisioning profile in the Apple Developer portal.
- Log in to the Apple Developer portal and create a new app ID for your app.
- Create a new provisioning profile for your app, which will allow it to access push notification services.
In Xcode, open your app project and select the project file from the project navigator.
Select your app target and click on the "Capabilities" tab.
Turn on the "Push Notifications" capability.
In the "Signing & Capabilities" tab, select the team for your app and choose the provisioning profile you created in step 1.

Once this is done, you’ll have enabled push notification capability in your iOS app and can start sending push notifications to your users through the Courier iOS SDK.

Setting up a notification service extension

So that you can better track your notifications, we recommend that you create a notification service extension in your iOS app.

A notification service extension is a type of iOS app extension that allows developers to track the delivery status of notifications and perform additional actions, such as modifying the content of a notification.

Setting up this extension allows Courier to accurately tell when your user receives a push notification when they are not using the app.

You can find a full setup guide here, on the Courier iOS SDK GitHub page. It won’t take long, and then Courier will be able to track delivery status in any state your app could be in.

Push notification permissions

The Courier iOS SDK needs to have push notification permissions granted by your users before it can access the push notification token. That’s where the requestNotificationPermission() function comes in.
Here's how it works:

if (await Courier.shared.requestNotificationPermission()) 
{ // Send some notification }

The requestNotificationPermission() function returns an authorization status that indicates whether the user has granted or denied permissions for push notifications.

You can read more about authorization status here.

Once your user has given access to receive notifications, a push notification device token is created by iOS and automatically synced to Courier.

Managing user state

Now that you've set up your notification service extension and handled permissions, it's time to focus on delivering a great user notification experience. One key part of this is keeping track of user state — the status of a user in relation to your app. This allows you to send users appropriate notifications based on whether they’re logged in or out. For instance, if a user is logged out, it wouldn't make sense to send them a notification about an activity that requires them to be logged in.

The Courier iOS SDK provides tools that help developers manage user state effectively and easily. By using the signIn() function provided by the SDK, developers can ensure that the user's push notification tokens and their state are kept in sync. Here's how to use the function:

await Courier.shared.signIn(
    accessToken: accessToken,
    userId: userId,
)

The accessToken can either be a Courier Auth Key used during development or a JWT (JSON Web Token) that should be used in a production app. You can create an access token by calling the Courier API as shown in the GitHub documentation. When the user signs out, you can use the signOut() function to clear their state.

The signIn() function saves the accessToken and userId to the native-level local storage, ensuring that the user's state persists between app sessions. This ensures that the user's push notification tokens are kept up to date.
By following these steps, you automatically sync push notification tokens and user state to Courier. This lets you ensure that push notifications are delivered at the right time and in the appropriate context for a better user experience.

Handling notification delivery

We've made it easy for you to monitor the delivery status of your notifications using the Courier iOS SDK via the onPushNotificationDelivered() function.

When a push notification is delivered to a user's device, onPushNotificationDelivered() is triggered automatically by the SDK if the app is in foreground. Here is an example implementation of the function in the AppDelegate class (the AppDelegate class is a key part of every iOS app and handles system-level events, including push notifications):

Courier analytics will track the delivery of this notification for you automatically.

class AppDelegate: CourierDelegate {

    override func pushNotificationDeliveredInForeground(message: [AnyHashable : Any]) -> UNNotificationPresentationOptions {
        print(message)
        return [.sound, .list, .banner, .badge] // Pass [] to hide any foreground presentation
    }
}

Note that this function will not be triggered when the app is in the "killed", "not running", or “background” state.

Handling a notification click

The pushNotificationClicked() function provided by the Courier iOS SDK can be used to handle user interaction with a notification inside your AppDelegate class. This function is called when the user clicks on a notification that was sent through Courier. Here's sample code for using the function:

Courier analytics will track the clicking of this notification for you automatically.

class AppDelegate: CourierDelegate {
  override func pushNotificationClicked(message: [AnyHashable : Any]) {
    print(message)
  }
}

In this example, the function simply prints out the content of the message payload. However, you can use the message to perform any number of actions in your app, such as opening a specific screen or executing a certain function.

Sending a test push

Now that you’ve set up your push notification infrastructure and know how to manage user state, you can start sending messages. The SDK allows you to send push notifications directly to a user ID without having to juggle tokens or manage a back end.

To send a test push notification, you can use the sendPush() function:

let messageId = await Courier.shared.sendPush(
    authKey: "a_courier_auth_key_that_should_only_be_used_for_testing",
    userId: "example_user",
    title: "Happy Holidays!",
    body: "Happy holidays from Courier.",
    providers: [.apns, .fcm],
)

Note that your user must have been given access to receive push notifications so that the push notification device tokens can be automatically synced to Courier and Courier can send a message to your user’s device. See “Push notification permissions” above for more details.

Conclusion

With just a few lines of code, you can streamline your push notification management and focus on building your product, thanks to the Courier iOS SDK.

By taking care of complex tasks such as token management and message delivery tracking, the SDK allows you to focus on building high-quality push notification experiences for your users.

If you’re an iOS developer, make sure to give the Courier iOS SDK a try and see how it can simplify and enhance your push notification workflow. Courier also has other SDKs available for Android, React Native, and Flutter. So if you're looking for a way to simplify your push notification management, check out Courier today.

Automate Slack and Microsoft Teams Notifications using Python

Shreya — Thu, 16 Mar 2023 16:28:47 +0000

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
Install Python 3.x on your computer
Install trycourier by running the pip install trycourier command

Create a Notification Template for Slack and Teams

Head over to the Notification Designer 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.

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.

Step 2: Create a Slack App

Navigate to the Slack Apps page and log into Slack. Click the Create an App button and provide your App Name as depicted below.

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

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.

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 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

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!

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

Slack Resources

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 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 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.

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.

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.

If you do not have a bot created already, follow these steps to create a new one. Also, make sure to save the password generated during the process. Keep the Messaging endpoint blank for the moment.

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 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, and a name for the repo.

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.

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

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.

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

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

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.

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.

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'])

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, 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.

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 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.

New Courier Inbox: Add a full-featured notification center to your app in minutes

Riley — Wed, 15 Mar 2023 17:18:49 +0000

Email and SMS are becoming increasingly busy channels. Sometimes, there’s no better way to reach a user than by sending a message to a notification center right inside of your app. However, building an inbox experience like this, from scratch, was a significant engineering effort.

Today, we are announcing a major update to Courier Inbox, a solution for developers to add an in-app notification center to their web application in a matter of minutes.

If you’re using the previous version of Inbox, we’ll cover the upgrade steps later in this post.

"With Courier, we added a beautiful inbox and in-app push notifications in a matter of weeks. We used the great looking pre-built component to save even more time. Notifications are not our core competency, so it made complete sense to integrate rather than build out and support our own implementation."

James Pipe, VP of Product, DroneDeploy

What is Inbox?

Courier Inbox is an in-app notification center for web applications (and mobile inbox coming soon). Inbox acts as a convenient in-app notification feed with a clean interface where users can view notifications in real time directly inside your web app. It also lets them view their message history of all past notifications that you’ve sent to them.

Using in-app notifications allows you to get users’ attention when they are in the application. This makes your communication with your users more timely and convenient: instead of interrupting them with an email on their phone when they are busy doing something else, you can use an in-app notification to provide information that is relevant to what your users are trying to do right now. Showing notifications within your web application increases user engagement — and provides a more seamless experience, as you can link users directly to relevant parts of the web app within these notifications.

While many companies are considering building notifications into their web app, not everyone has the time or resources to build a full-fledged notification center. We first implemented Inbox two years ago together with the web-based pop-up notification functionality, and customers loved it exactly because it takes so little time to start using it.

The notifications that customers send via Inbox may include application activity such as discussions, new events, comments, alerts, and reminders, as well as news about feature updates.

Based on customer feedback, we’re excited to announce improvements to the Inbox functionality. Meet the new Inbox.

Introducing the new Inbox

The new Inbox has all the benefits of the original Inbox: it’s fast to implement via pre-built Courier JavaScript components, it offers an intuitive user experience, the design is customizable to your needs, and it natively integrates with the rest of the Courier platform. On top of that, Inbox includes a number of improvements, in terms of both design and functionality.

On the design side, we took customer feedback on board and simplified how the inbox looks and feels. Specifically, here’s what changed:

Visually, the inbox now looks more modern so that it fits better into customer apps.
There are no more separate tabs for read and unread messages — this separation into tabs previously led to confusion. Now everything is displayed more clearly in a single feed.
Hovering over a message now shows a check mark or cross to mark a message as read or unread, instead of a vertical three-dot menu taking up screen real estate.
Unread messages are identified by a colorful logo (vs. gray for unread), and the colors are customizable. A colored dot appears at the top showing how many unread messages there are in the inbox.
Hovering over a message makes the background of that message change color if it is clickable. Short messages where all the text can be viewed at a glance are not clickable and don't change color on hover.

Notification state is now synchronized between the inbox and other channels. For example, if a notification was sent as in-app and email, reading the email will mark the in-app notification as read.

Another new feature is message expiration. It’s now possible to set a timeline for the message to expire, say 7 days, and after that time the message will be removed from the inbox. This feature can help avoid a mess of older notifications for users that rarely sign into the web app.

The advanced branding options, including applying brand settings (we cover this below) and removing the Courier logo, as well as message retention are available on our Developer and Business tiers.

New RudderStack Integration: Create Actionable Insights

Tejas Kumthekar — Wed, 08 Mar 2023 17:00:32 +0000

Are you looking for a way to gain a clearer picture of your users and use that insight to improve your communication strategies? We've got some great news for you! Today, we're thrilled to announce an integration between Courier and Rudderstack, a customer data platform (CDP) that allows businesses to collect, process, and route customer event data across product, marketing, and analytics tools for better decision-making.

This integration builds on our recently improved integration with Segment and will further improve your ability to track your users' actions and take advantage of customer data stored in RudderStack to improve the notification experience for your users.

"Courier makes it easy to trigger notifications based on RudderStack events. We're really excited about this integration because it removes a lot of complexity for engineers and data teams looking to build a notification system."

Eric Dodds, Head of Product Marketing, RudderStack

For those who may not be familiar with RudderStack, it’s a customer data platform (CDP) that allows businesses to collect, process, and route customer event data across product, marketing and analytics tools for better decision-making. As for Courier, it’s an all-in-one notifications solution that enables development teams to manage communications with their users, from product notifications to marketing messages, through a number of channels, such as email, chat, in-app messages, SMS, and push, all in one place.

So, by integrating Courier with RudderStack, you get the combined benefits of both systems: you can now collect, process, and route your users' interaction data between Courier and different marketing and analytics tools, via RudderStack. This integration can help you gain a clearer picture of your users and use that insight to improve your communication strategies.

You can also track notification engagement data, such as the percentage of communications that were successfully delivered, opened and read, and on what notification channels. The detailed notification analytics data gives you the potential to create more personalized app experiences for users based on their activity within your product. For example, you could adjust the way a user receives notifications based on their interactions with your product, as well as data from Salesforce, Google Ads, Mailchimp, and other RudderStack sources.

More about Courier

Courier is an API and web studio that centralizes all product-triggered communications, such as email, chat, in-app messages, SMS, and push notifications. With Courier, businesses can deliver messages to their users using their preferred communication channels, with real-time visibility and tracking for each message. This tracked data within Courier can now be passed to RudderStack!

One of the best things about Courier is that it provides a single, unified interface for developers to manage all communications. This reduces complexity and eliminates the need for developers to manage multiple APIs and libraries to send notifications to various channels. Courier's simple and elegant APIs make it easy for developers to create new notifications and manage messages in a way that doesn’t require additional work for each new notification channel.

More about RudderStack

RudderStack, as we already mentioned, is an easy-to-use CDP, with a straightforward installation process and intuitive user interface. It doesn’t require any in-depth technical knowledge, making it a popular choice for businesses that want to collect and process customer data without the need for a dedicated development team.

Unlike most other CDPs, RudderStack is open-source, which means that developers can access the source code, modify it to suit their needs, and contribute to the development of the platform. Additionally, RudderStack offers a range of pricing plans, including a free plan, making it accessible to businesses of all sizes. Another great feature of RudderStack is that you can host it in your private cloud infrastructure, giving you even more control over your data.

RudderStack’s control plane

The RudderStack platform consists of two main components: the user-facing control plane and the data plane that operates under the hood. In this section, we'll take a closer look at the control plane.

The control plane is the web-based interface that allows you to manage data integrations, monitor data flows, and control user access. It's the place where you can configure and manage your RudderStack accounts, add and remove integrations, and control who can access data.

RudderStack’s control plane also lets you manage your data integrations easily. For instance, you can set up and choose your data destinations and sources, control who can access the data, and monitor the flow of data between the sources and destinations.

In RudderStack, sources are platforms or applications from which RudderStack tracks and collects data. A destination, on the other hand, is a cloud tool or a platform where you want to send this collected data.

From the control plane, you can also create custom transformations and enrichments to modify the data before it gets sent to the destination. These features provide you with granular control over your data integrations and allow you to create custom data pipelines that fit your specific needs.

Events — the data sent by Courier

There are two types of user data Courier can now send to RudderStack: message events and audience events.

Message events are all about notification deliverability and user engagement. These events track whether a message was sent, delivered, clicked, and opened. Message events help businesses track notification usage data, including successful deliveries, opens, clicks, and the channels through which messages are sent. This data can help businesses create custom user journeys that are tailored to users' communication preferences, improving the overall user experience.

Audience events, on the other hand, make use of Courier's dynamically defined user groups, known as audiences. Audiences give you more flexibility than static lists. For instance, you can define an audience as a set of users with the title “Software Engineer.” You can even take this one step further and define more niche audiences by specifying that the user also has listed, for example, TypeScript as one of their favorite programming languages.

Audience events allow you to track when people join or leave these pre-defined groups based on changes in user characteristics, allowing for better data collection and therefore improved end user experience. For example, an audience event would be triggered if someone changed their job title to “Software Engineer” or if they changed it from “Software Engineer” to something else. This gives you control over the type and amount of notifications specific users receive, improving their overall experience.

Using this new data

When your events have been loaded in RudderStack, you can use different aggregate views to study them, or you can forward them to an analytics destination like Looker or Tableau. This integration enables you to perform analytics on your notification data, giving you powerful insights about how your users interact with your product, and create even more enjoyable notification experiences.

You can also automatically update information in Courier from your product or from other software tools via RudderStack. For example, if a user changes their email address in your web app, you can propagate that information into the user’s profile in Courier without the need to add a separate Courier API request.

What are you waiting for?

Whether you're new to RudderStack or an existing user, integrating Courier is a straightforward process. To enable the integration, add Courier as a source and/or destination. Adding Courier as a destination is as simple as specifying Courier as a "destination" in your RudderStack dashboard. Just navigate to ‘directory’, go to the destinations tab and search for Courier.

For more detailed information on how to implement courier as a source or destination, and help getting started with the RudderStack and Courier integration, visit our documentation and follow the steps outlined there. This will start the flow of data and can start giving insights straight away, helping you to improve your user experience and helping you make better product decisions.

Introducing Courier Preferences: The Fastest Way to Design the Best Preference Experience

Charla Bigelow — Thu, 23 Feb 2023 16:32:17 +0000

Notification preferences are important — especially if you’re building an application that sends dozens of notifications. Users want control over which kind of notifications they receive, and through what channels. That’s why it is essential to provide a well-designed preference experience that’s quick, intuitive, and guaranteed to respect your users’ chosen preferences.

With Courier, you can build great notification infrastructure effortlessly. But until now, preferences were handled separately, requiring engineers to spend a significant amount of time on both the back-end logic and the UI where users could select which notifications they want to receive and how.

As an engineer myself, I’ve had to build workflows like this several times in past projects & companies. But those days are over: we’re excited to announce general availability of Courier Preferences. With Courier Preferences, you can build a full notification Preference Center in no time. The clean interface, which comes with endless options for customization, lets users manage their preferences. Courier’s infrastructure will take care of the rest by integrating them into our core products that trigger sends.

(Within the Preference Center, users can comfortably opt in and out of notifications by topic and channel)

Whether you want to build a bespoke notification experience with the Preferences API, embed our pre-built UI components, or use the hosted preferences page that Courier provides out of the box for faster time to value, is entirely up to you.

"Courier turned something that takes months into days. We were able to unlock the ability for our users to opt in/out of notifications in a customized Preference Center within one day. It was easy."

Guilherme Samora, Senior Product Manager, Sastrify

In this post, we’ll look at how to implement the best preference experience for your users. We’ll talk about how Courier makes it easy to handle preference settings and logs, and how the new Preferences Designer makes preference management a walk in the park. But first, let’s briefly recap why it’s important to implement preferences for your users.

Notification preferences are a vital feature of any app

Aside from their core functionality of alerting your users to activity in the app that requires their attention, notifications can be used to increase users’ awareness of your product’s features, for marketing and other purposes.

But getting all these kinds of notifications from different organizations can quickly become annoying for users. To make sure they remain in control of their own notification experience, and to avoid them turning off all notifications from your app, it is vital that you implement notification preferences that are fine-grained and easy to use. And it’s just as important that you respect those preferences and only send your users the notifications they really want.

Building notification preferences for your app from scratch is hard, especially if you use more than one channel to communicate with your users. It requires a significant amount of time and engineering resources — and don’t forget the need for future maintenance. By letting Courier host your preference infrastructure, you can instead use those resources to focus on building your core product.

Here at Courier, we have spent quite some time thinking about what the best preference experience looks like. It needs to be clean, customizable, and easy to use for the end users. It also needs to offer sufficient transparency for compliance and record-keeping purposes on the back end. Since these requirements align across products, there is no need for every company to build their own. Instead, Courier Preferences lets you set up the notification experience that you want for your users in just a few hours.

How to design a good preference experience

You can now use the Preferences Designer in the Courier web interface to design the best preference experience for your users. (As an alternative to the Preferences Designer, you can use the Preferences API for a more native experience within your app — more on that later.)

Since most applications send out many different notifications, it can quickly become cumbersome for users to manually set preferences for every single option. For a better user experience, Courier groups notifications by subscription topics (formerly called “categories”). In addition, business tier Courier customers can bundle several topics by sections: as an example, you could set up two topics named “Feature launch” and “Product update” and file them both under a “Product” umbrella section, for even easier preference management.

Turning notifications on and off is not all, however. Notifications can be sent via different channels in Courier, such as email, SMS, and push notifications. Users can select which channels they prefer for each subscription topic. For instance, they might prefer to be notified via email about a new message or rating on a social media platform, but not about minor interactions such as likes. Conversely, they may want to activate multiple channels — like SMS, email, and Slack — if there’s an emergency, like a security breach.

As a developer, you can turn certain notifications on and off by default for different topics and channels. You can also set certain indispensable notification topics as required. By marking a notification topic as required (for example, "Reset Password"), it prevents your users from disabling notifications for that topic, while reassuring them that they’ll still receive such critical notifications even if they disable everything else.

Voilà: a user-facing Preference Center

In the Preferences Designer, you can preview how your users will see the Preference Center in their browser. The page is designed to be easily navigable: preferences for notification topics and channels can be turned on and off with the click of a mouse.

All of these features are available in our free tier. For more functionality, like multiple sections or the ability to remove the Courier watermark from the user-facing Preference Center, use our Business plan.

Your preference UI, hosted by Courier

You can now direct users to their personal Preference Center through a hyperlink in your notifications to them. In newer Courier workspaces, your notification templates will include this hyperlink by default. Otherwise, you can add the link manually.

By following the link, your users will be able to see and update their own notification preferences within the Preference Center. Note that this requires no login: by automatically encoding their user_id in the Preference Center hyperlink, it will be personalized to that user, and their preferences will be saved in their profile in the back end.

And that’s it: the easiest way to create the best customized preference experience, with only a few clicks in the Courier Preferences Designer.

Build your own interface via the Preferences API

You don’t have to use the hosted Preference Center — you can build your own, or even integrate notification controls elsewhere in your application. Have a look at the documentation for the Courier Preferences API to learn more.

Finally, you can choose the middle ground and embed Courier’s prebuilt component in your own preferences UI.

A user-friendly unsubscribe experience

Unsubscribing from unwanted notifications should be fast and easy — and you should make sure to respect your users’ preferences to avoid unnecessary frustration. Similar to the preferences hyperlink, you can easily embed an unsubscribe link in your notification template. By clicking on it, users can unsubscribe from topics that they’re not interested in.

Keeping a digital paper trail of your users’ preference history

Keeping logs of your users’ changes in preference settings is useful for debugging, compliance, and solving issues in customer support. Courier automatically logs all your users’ changes in notification preferences and lets you view them via the API or directly in the Courier web interface.

Let’s say, for instance, that a user isn’t receiving your notifications, even though they were enabled in their settings. You can now simply check the logs to determine where the error occurred. Conversely, a user might complain that they’re still receiving unwanted notifications after they thought they turned them off. By looking at the preference logs, you can see whether they indeed turned notifications off, or if they accidentally enabled them.

Get started with Courier Preferences today

Being able to offer users a fine-grained and intuitive preference experience saves companies a lot of time and puts them further ahead on their roadmap. We’re excited to make preference management easy and smooth for businesses.

To learn more and start designing the best preference experience for your audience, take a closer look at Courier Preferences and the docs. We’re sure your users will love it!

Forem: Courier

Sending Scheduled and Recurring Email Notifications with PHP

Configure an email service provider in Courier

Create a notification template in Courier

Option 1: directly send a scheduled or recurring email using Courier

Preparing your PHP environment

Sending a scheduled email

Sending a recurring email

Using Laravel? It’s already got scheduling baked in

Option 2: use Courier’s automations to add send logic to your scheduled emails

Examples of when to use automations

Sending two scheduled emails in one automation

Dynamic automations API documentation

Option 3: use Courier’s no-code automations designer to build complex logic around scheduled emails

Create a notification template

Create an automation template

Sending digests on a recurring schedule

Conclusion

A Developer’s Guide to Notification APIs

Understanding and using notification APIs

The role of notification APIs in transactional versus marketing notifications

Benefits of using a notification API for developers

Sample use cases for notification APIs

Conclusion

Courier Inbox for web and mobile, a complete notification center

Options to build with Courier Inbox

Real-world examples

DroneDeploy

LaunchDarkly

Oyster HR

Integrating Courier's notification inbox

Adding a notification center to your web application

Adding a notification center to your IOS application

Adding a notification center to your Android application

Alternative, headless approach to building an inbox with Courier

Next steps

How to Create an Automated SMS Notification System

Introduction

Send with SMS

Integrate SMS API

Create Your Notification(s)

Create an Automation

Set up user preferences

Best Practices for SMS Notifications

A. Timing and frequency of SMS notifications

B. Personalizing the SMS notifications for each recipient

C. Measuring the success of SMS notifications with analytics

D. Improving the SMS notification strategy based on recipient engagement

Conclusion

New Datadog integration for Courier notification logs and metrics

The fastest way to pull your notification data into Datadog

Use cases

Notification metrics and logs

Feature-specific metrics and logs

What data can be sent to Datadog from Courier?

Metrics

Logs

Setting up the Datadog integration

Next steps

Streamline your workflow with CourierJS: Our new client-side SDK

Client-side vs. Server-side SDKs

Discover the advantages of CourierJS

Ready to get started? Using CourierJS is a breeze

Exploring the new API calls in Courier's client-side SDK

The identify call

Subscribing and unsubscribing from lists

Conclusion

Introducing the new and improved Automations designer

What is Courier?

What are Courier automations?

The elements of a Courier automation

Triggers

Actions

Branching logic

Why the new version of the Courier automations designer helps you

How to use the automations designer

The automations API

Details for existing users of the automations designer

Differences between the old and new automations designer UIs

What you need to do to migrate to the new version of automations

The `identify` call